DEV Community: Vignesh J

How GitHub Copilot Helped Me Roast Its Own Users

Vignesh J — Mon, 26 Jan 2026 10:56:47 +0000

This is a submission for the GitHub Copilot CLI Challenge

What if GitHub Copilot didn’t just help you write code but judged you for it?

What I Built

I had been waiting for a challenge that truly sounded like me for a long time, and that’s when the GitHub Copilot CLI Challenge showed up.

Within five minutes, the idea that popped into my head was to use Copilot CLI to do something with Copilot itself.

That’s when the idea of roasting the user for their GitHub Copilot usage came up.

Then I started wondering how to implement it.

Whether to build something that runs in the terminal but that would consume RAM.

Should I try a different approach?

That’s when the idea of a VS Code extension popped up (GitHub CLI actually helped me there 😉).

This was my first time using an AI pair programmer to help me build a project completely, because I had never built, or even thought about creating a VS Code extension before.

The roasts are static for now and don’t use AI, because I couldn’t afford an API key 😩.

Demo

Click the following link:
Copilot Roaster Extension

Install the extension using the link.

And your setup is complete.

Then, open any sample file to test it.

Ask GitHub Copilot to write something and accept its suggestion to see the magic ✨

Find my demo below:

Demo

You can find the GitHub repository here.

Feel free to fork, modify, and upgrade it.

My Experience with GitHub Copilot CLI

This was my first time using an AI pair programmer in the CLI. I was really excited to see how it worked. After installing it and typing copilot in the terminal, it felt like magic when this showed up.

I started wondering how it would work, which subscription it would use and which profile it would be linked to.

While thinking about all this, I typed a prompt, and that’s when I got an error saying I needed to log in to proceed further.

First, we need to use /login to sign in with our GitHub account.

After that, everything was smooth. The suggestions were almost exactly what I expected (maybe my prompt was too good 😉).

Then I tweaked things a bit, and tadaaa 🎉

The extension was ready and looked cool.

I added a few more roasts just to make sure the same ones didn’t repeat.

Then I published it on the Marketplace.

GitHub Copilot CLI provided me with the exact steps to publish the extension, because I had no clue how to do it and the whole process was smooth as well.

So go ahead, install the extension, let Copilot write your code, and brace yourself… because this time, you’re the one getting reviewed 😏

Follow me on Linkedin | GitHub | Twitter

Subscribe to my newsletter and get articles delivered straight to your inbox.

The Developer Stack | Vignesh J | Substack

Stay ahead with 'Technical Bytes' and insider stories from corporate work life, delivered straight to your inbox. Click to read The Developer Stack, by Vignesh J, a Substack publication. Launched 8 months ago.

thedeveloperstack.substack.com

SQL vs NoSQL: Choosing the Right Database Before It Chooses Your Fate

Vignesh J — Sat, 09 Aug 2025 11:25:36 +0000

SQL or NoSQL - the debate isn’t just about databases, it’s about how your application will think, grow, and scale.

Pick the wrong one, and you might end up fighting your database instead of building your product.

What if the database you choose today becomes the reason your app slows down, fails to scale, or costs you thousands to fix later?

Let’s make sure that never happens.

Choosing between SQL and NoSQL is one of the most important decisions you’ll make when designing a data-driven application.

Both have their strengths, weaknesses, and ideal use cases and the choice can shape your system’s performance, scalability, and even your development speed.

In this guide, we’ll break down what SQL and NoSQL are, where each shines, their pros and cons, and how to decide which one’s right for you.

What is SQL?

SQL (Structured Query Language) is a standardized, domain-specific programming language used to access, manipulate, and manage data within relational database management systems (RDBMS).
Data is organized into tables with rows and columns, enforcing a strict schema. Examples of SQL operations include SELECT, INSERT, UPDATE, DELETE, and advanced queries involving JOINs.

What is NoSQL?

NoSQL (“Not Only SQL”) refers to a broad category of non-relational databases that store and retrieve data differently from traditional table-based databases.
NoSQL databases come in many types: key-value, document, wide-column, and graph. They allow for flexible schemas and are designed for high scalability, performance, and handling unstructured or semi-structured data.

Uses of SQL and NoSQL Databases

SQL

Suitable for applications needing consistent, structured data: finance systems, ERP, CRM, e-commerce, and any domain where ACID transactions and complex queries are crucial.
Commonly found in analytical workloads, data warehousing, and transactional systems.

NoSQL

Used when flexibility and scalability are necessary: big data analytics, social networks, content management, IoT, and mobile applications.
Ideal for handling rapidly evolving data models, storing large amounts of unstructured data, and supporting horizontal scaling across multiple servers.

When Should You Use SQL vs NoSQL?

SQL is best when:

Your data is structured and fits well into tables (tabular model).
You need strong data consistency (e.g., financial transactions).
Your application requires complex queries and joins.

NoSQL is preferable when:

The data is unstructured, semi-structured, or changing frequently.
Scalability and distributed architectures are important (e.g., web-scale apps, IoT, streaming data).
You need high write/read throughput, flexible schema, or must store large datasets with minimal overhead.

Popular SQL and NoSQL Databases

Category	Database	Highlights
SQL	MySQL	Open-source, widely used for speed/reliability
	PostgreSQL	Advanced features, strong consistency, robust
	Oracle	Scalable, enterprise features, commercial
	Microsoft SQL Server	Integration with MS ecosystem, commercial
	SQLite	Lightweight, file-based, serverless
NoSQL	MongoDB	Document store, JSON-like documents, flexible schema
	Apache Cassandra	Wide-column store, high scalability, fault-tolerant
	Redis	Key-value store, extremely fast, in-memory
	Couchbase	Document + key-value, scalable, mobile/cloud-friendly
	Neo4j	Graph database, excels at modeling relationships

Pros and Cons

SQL Databases

Pros:

Strong data consistency (ACID properties).
Powerful query capabilities, including JOINs and aggregations.
Mature ecosystem, well-supported in enterprise environments.
Standardized language and strong transactional support.

Cons:

Rigid schema; structure changes are complex.
Vertical scaling (limited by hardware upgrades).
Can become resource-intensive with large volumes of data.
Less ideal for unstructured or semi-structured data.

NoSQL Databases

Pros:

Highly scalable via horizontal distribution across servers.
Flexible schema; dynamic data models.
Good performance under heavy load or with big data volumes.
Suitable for rapid development and changing requirements.

Cons:

May sacrifice strong consistency for performance (eventual consistency).
Limited support for complex queries and joins.
Diverse models (key-value, document, graph, etc.) – learning curve can
be steeper.
ACID guarantees may be absent or limited.

Now let’s dive deep into the Pros and Cons

What Are ACID Properties?

ACID is a set of four guarantees that make transactions in a database reliable:

Property	Meaning	Why It Matters
A - Atomicity	A transaction is all or nothing. If any step fails, the whole thing rolls back.	Prevents partial updates (e.g., money deducted from one account but not added to another).
C - Consistency	The database moves from one valid state to another. All rules (constraints, triggers, etc.) are followed.	Ensures data integrity.
I - Isolation	Transactions don’t interfere with each other. Even if they run at the same time, the result is as if they ran one after the other.	Prevents race conditions.
D - Durability	Once a transaction is committed, it’s permanent even after a crash or power loss.	Ensures data isn’t lost unexpectedly.

How SQL Databases Support ACID

Traditional relational databases like MySQL, PostgreSQL, Oracle, SQL Server are designed around ACID.

How they do it:

Atomicity → Transactions can be started with BEGIN and rolled back with ROLLBACK if anything fails.
Consistency → Enforced using:
- Data types
- Constraints (PRIMARY KEY, FOREIGN KEY, CHECK)
- Triggers & rules
Isolation → Achieved using locking and isolation levels (READ COMMITTED, SERIALIZABLE, etc.).
Durability → Achieved through:
- Write-ahead logging (WAL) -changes are logged before applying.
- Data replication and backups.

Example:

BEGIN;
UPDATE accounts SET balance = balance - 500 WHERE id = 1;
UPDATE accounts SET balance = balance + 500 WHERE id = 2;
COMMIT;

If any update fails, SQL ensures the whole operation rolls back.

Why Many NoSQL Databases Don’t Fully Support ACID

Many NoSQL databases (e.g., MongoDB, Cassandra, Couchbase) prioritize scalability and availability over strict ACID — especially when distributed across many servers.

Challenges:

Distributed nature → Keeping strong ACID across multiple nodes is expensive and slow.
Instead, many follow BASE:
- Basically Available → System is always responsive.
- Soft state → Data may change over time (eventual consistency).
- Eventual consistency → All replicas will agree eventually, but not instantly.
Many NoSQL systems relax Isolation and Consistency to gain:
- Faster writes
- Easier horizontal scaling
- High availability in case of network failures

❗Important Note

Not all NoSQL is non-ACID, some have partial or optional ACID support.
- MongoDB → ACID transactions for multi-document operations (since v4.0), but with performance trade-offs.
- Cassandra → Lightweight transactions with limited isolation.
But by default, most NoSQL systems lean towards BASE for performance and scalability.

SQL databases are less ideal for unstructured or semi-structured data

SQL databases are less ideal for unstructured or semi-structured data mainly because of how they’re designed at their core.

1. SQL Databases Expect a Fixed Schema

In SQL, you must define a schema (tables, columns, data types) before inserting data.
Every row in a table must follow this schema.
Problem with unstructured data:
- Unstructured (e.g., images, videos, free text) and semi-structured (e.g., JSON, XML) data doesn’t fit neatly into rigid tables.
- If the shape of the data changes often, you’d need to alter the schema repeatedly which is expensive and disruptive.

2. Data Fits Poorly into Rows and Columns

SQL databases are row-and-column oriented.
Unstructured data often has:
- Varying fields per record.
- Optional or nested attributes.
Trying to store this in SQL means:
- Many NULL values for unused columns.
- Complex join tables to represent nested relationships.
- Reduced performance.

3. Complex Storage for Nested or Variable Data

Semi-structured data like JSON can be stored in modern SQL databases (e.g., PostgreSQL’s jsonb), but:
- It loses many of the query optimizations of relational tables.
- Indexing and searching within JSON fields is slower and more resource-intensive.
NoSQL document databases (like MongoDB) handle nested, variable fields natively, making them faster for such use cases.

4. Scaling and Flexibility Issues

Unstructured/semi-structured data grows in unpredictable ways.
SQL’s strict schema + vertical scaling approach makes it harder to adapt.
NoSQL’s flexible schema + horizontal scaling is a better fit for changing and large-scale unstructured datasets.

NoSQL databases support a flexible schema

When we say NoSQL databases support a flexible schema, we mean:

1. No Predefined Table Structure

In SQL, you must define all columns and their types before inserting data.
In NoSQL (e.g., MongoDB, Cassandra, DynamoDB), you don’t have to predefine all fields.
You can insert a record with certain fields and another record with completely different fields in the same collection/table.

2. Different Records Can Have Different Structures

Example in MongoDB (Document Database):

// Document 1
{
  "name": "Vignesh",
  "email": "vignesh@example.com"
}

// Document 2
{
  "name": "Raj",
  "phone": "9876543210",
  "address": {
    "city": "Chennai",
    "zip": "600001"
  }
}

Here:

Vigneshhas an emailfield but no phone.
Raj has a phone and nested addressbut no email.
Both are stored in the same collection without schema changes.

3. Easy to Evolve

You can add, remove, or rename fields anytime without altering the entire database structure.
This is especially useful when:
- Your data model changes often.
- You’re storing unstructured or semi-structured data (e.g., JSON, XML).
- You have to handle diverse data sources with different formats.

4. Schema-on-Read vs Schema-on-Write

SQL uses schema-on-write → structure is enforced when data is inserted.
NoSQL often uses schema-on-read → structure is applied when data is retrieved/processed.
This means you can store raw, irregular data and shape it later.

What is Vertical Scaling (Scale Up)?

Meaning: Increasing the capacity of a single machine (server) to handle more load.
How it’s done: Add more CPU, RAM, storage, or faster disks to the same server.
Analogy: Like buying a bigger, faster laptop instead of having multiple laptops.

SQL Databases and Vertical Scaling

Traditional SQL databases (like MySQL, PostgreSQL, Oracle) store data in a structured, relational format.
They are often designed to run on a single powerful machine for consistency and complex queries.
Scaling horizontally (across multiple servers) is harder for SQL because:
- They rely heavily on transactions (ACID compliance).
- Data is often interrelated (joins across multiple tables).
- Splitting (sharding) the data while preserving relationships is complex.
So the simpler approach has been:

Make the one machine stronger → Vertical scaling.

What is Horizontal Scaling (Scale Out)?

Meaning: Adding more machines (servers) to distribute the load.
How it’s done: Use multiple servers that share the workload, often with data spread across them.
Analogy: Instead of buying a supercomputer, you buy 10 normal computers and make them work together.

NoSQL Databases and Horizontal Scaling

NoSQL databases (like MongoDB, Cassandra, Couchbase) store data in a non-relational way (documents, key-value pairs, wide-columns, etc.).
They are built with distribution in mind from the start:
- Data can be sharded across multiple servers easily.
- Each server handles a portion of the data.
- This allows handling huge datasets and high traffic by just adding more machines.
So the common scaling method is:

Add more servers to share the work → Horizontal scaling.

Conclusion

Choosing between SQL and NoSQL isn’t about which one is better in a vacuum. It’s about which one aligns with your data model, growth plans, and application needs.

Think of it like building a house: you wouldn’t choose the same foundation for a skyscraper as you would for a cabin.

If you need structure, consistency, and reliability, SQL databases offer proven stability.
If you need flexibility, speed at scale, and evolving data models, NoSQL can give you the agility you need.

The most successful projects start with clarity, not guesswork.

Pick the right database today, and you won’t just avoid costly mistakes, you’ll set your application up to scale gracefully for years to come.

Follow me on Linkedin | GitHub | Twitter

Subscribe to my newsletter and get articles delivered straight to your inbox.

The Developer Stack | Vignesh J | Substack

thedeveloperstack.substack.com

Retro’ing and Debugging 2024 - A year of learning and fun

Vignesh J — Wed, 08 Jan 2025 13:50:39 +0000

This is a submission for the 2025 New Year Writing challenge: Retro’ing and Debugging 2024.

First of all, Happy New Year, everyone!

Let all your dreams come true, and may you reach the goals that you’ve set.

This is my first blog of 2025. I am going to reflect on how the year 2024 went for me.

And where should I start?
2024 has been an amazing ride for me. I’ve learned a lot more in 2024 than any other year.

January

January was the holiday season for me. I was enjoying my life.

February

In February, I started learning CPP. I learned some syntaxes and solved some problems. However, I took a break because of my college project.

March

In March, I was busy with a college project. Documenting the project was the hard part!
However, we completed it.

April

In April, I started solving problems from a book called “Let Us C” by Yashavant Kanetkar.
It took me 2 months to solve all the problems. You can find the solutions here ↓

Vignesh025 / Let-us-C

Solutions for Let us C -19th Edition

May

In May, I was solving the “Let Us C” problems, and I was also spending a lot of time watching football as it was a peak season.

June

In June, I was exploring the internet about what to do next and what to learn next.
I also tried to make a website for the solutions I made for “Let Us C.”

July

In July, I started my full-stack web development journey. I started with the MERN stack.

This is one of the most important months of my life:

I joined Dev.to and started my habit of reading blogs.
I joined an open-source program called “Code Sapiens.”

This is when I learned a lot about open source and started contributing to it.

August

In August, I started my first full-stack project as a part of my learning journey called CampX.
You can find the project here ↓

Vignesh025 / CampX

"CampX: Discover and share the best campgrounds across Globe, where adventure meets community."

CampX

Introduction

CampX is a web application designed to help users discover and share campgrounds from around the world. Users can browse through a collection of campgrounds, read reviews, and contribute by adding their own. Each user has control over the campgrounds they add, with the ability to edit or delete them. The platform encourages a community-driven approach to exploring the great outdoors.

Features

Global Campground Discovery: Browse campgrounds from various locations worldwide.
User-Generated Content: Users can add campgrounds and reviews.
Edit and Delete Permissions: Only the original author of a campground can edit or delete their entry.
Interactive UI: Engaging interface built with HTML, CSS, and JavaScript.

Hosted Website

Visit the live version of CampX here: CampX Website

Tech Stack

Frontend: HTML, CSS, JavaScript
Backend: Node.js, Express.js
…

View on GitHub

September

In September, I finished my full-stack project, and guess what?
This is the month when I posted my first Dev.to blog.

I’ve shared about my project there. You can find the post here ↓

🚀 Introducing CampX: An Open-Source Node.js, MongoDB, and Express Project – Your Contributions Welcome! 🌟

Vignesh J ・ Sep 7 '24

#webdev #node #express #mongodb

In late September, I created a GitHub organization and made my first full-stack project open source. You can find the project here ↓

VigneshDevHub / CampX

"CampX: Discover and share the best campgrounds across Globe, where adventure meets community."

Star our Repository ⭐

CampX

Introduction 🤝

Code of Conduct 📄

We are committed to fostering a welcoming and inclusive environment for everyone. Please take a moment to review our Code of Conduct, which outlines our expectations for participant behavior and how we handle reports of misconduct.

By participating in this project, you agree to abide by our Code of Conduct.

Table of Contents 📖

Features 🛒

Global Campground Discovery…

View on GitHub

I prepared it for the most anticipated season of every year: the Hacktoberfest season.
The project was also enrolled in Hacktoberfest and GSSoC-2024 Extd.

October

October was one of the busiest months of the year:

Maintaining the project as well as contributing to other open-source projects.
Participating in another open-source program called “DevFest” as a contributor.
Attending many sessions and learning a lot of new stuff.

November

In November, I was posting about my October month contributions online.
I also started a new blog series on Dev.to about “Computer Networking.”
You can find it here ↓

Introduction to Computer Networking: A Beginner's Guide to How the Internet Works

Vignesh J ・ Nov 11 '24

#computernetworking #beginners #webdev #interviewprep

I joined the Azure Developer Community on Discord. It was so fun attending the quizzes, and the most interesting part is that they reward the winners with swag. There were many engaging sessions on various topics.

December

In December, I completed my blog series on “Computer Networking.”
I started my learning journey on the Java and Spring frameworks.

I also won a quiz conducted by the Azure Developer Community. Yay!

So this is how my 2024 went.

It was a year of learning and fun.

If I could change anything from 2024, I wouldn’t change a thing because I believe everything happens for a reason.

If you like my content, you can follow me here:

Understanding the Data Link and Physical Layers: The Final Step in Mastering OSI Model and Computer Networking

Vignesh J — Sat, 14 Dec 2024 13:41:00 +0000

This is the eighth and final part of the computer networking series. Check out the previous parts if you haven't. In this part, we'll see about:

Data Link Layer
Physical Layer

Data Link Layer
Physical Layer
Conclusion

Data Link Layer

The data link layer is responsible for sending the data packets received from the network layer over a physical link.

In the data link layer, the data is sent as frames.

If many devices are connected in a LAN, the devices communicate with each other using their data link layer addresses.

If you don't know what a LAN is, we've already discussed it in a previous part. You can check it here ↓

Exploring Network Types and Topologies

Vignesh J ・ Nov 13 '24

#computernetworking #beginners #webdev #interviewprep

Example of Communication in a LAN

Consider A, B, C, and D connected in a LAN, and A wants to send data to D:

Checking ARP Cache:
- First, A checks its cache memory (known as the ARP cache) for D's data link layer address.
Broadcast Request:
- If the address is unavailable, A sends a message to all devices in the network asking for D's data link layer address.
- The message is a frame that includes:
  - The data link layer address of the sender (A).
  - The IP address of the destination (D).
  - A request for the data link layer address of the destination.

Address Resolution Protocol (ARP)

ARP Cache: Stores mappings of IP addresses to data link layer addresses.
MAC Address:
- A unique 12-digit alphanumeric string that serves as the data link layer address.
- Stands for Media Access Control.

The data link layer works closely with the physical layer to ensure communication.

Physical Layer

The Physical Layer is the bottom-most layer in the OSI Model. It represents the physical and electrical aspects of the system.

Key Features of the Physical Layer

Hardware Components: Includes power plugs, connectors, receivers, and cable types.
Transmission of Data Bits: Responsible for sending unstructured raw data streams from one device (e.g., a computer) to another.
Encoding: Defines how 0s and 1s are encoded into signals for transmission over the physical medium.

The Physical Layer is responsible for communication over a physical medium like cables and wireless systems.

Conclusion

This marks the end of the OSI model and also the end of this series. I hope you’ve gained insights into some basic computer networking concepts necessary to understand how the internet works.

Remember, computer networking is a vast field with much more to explore. This series provides a foundational overview, but you can dive deeper into specialized topics by exploring additional resources.

Make sure to react and leave your feedback in the comments! It would be really helpful to understand what is good and what I need to improve.

If you like my content, you can follow me here:

Thank you for following along this journey!

Understanding the Network Layer and IP: Routing, IPv4 vs IPv6, and Key Concepts Explained

Vignesh J — Sat, 07 Dec 2024 10:30:00 +0000

This is the seventh part of the computer networking series. Check out the previous parts if you haven't. In this part, we'll explore the Network Layer and Internet Protocol (IP).

Network Layer
- Control Plane
- Forwarding and Routing Tables
Internet Protocol (IP)
- IPv4
  - Classes of IP Addresses
  - Subnet Masking
  - Reserved Addresses
  - Packets in IPv4
- IPv6
  - Cons of IPv6
  - IPv6 Format
Middleboxes
- Firewalls
- Network Address Translation (NAT)

Network Layer

In the Network Layer, we work with routers. If you're unfamiliar with routers, check out our earlier discussion here ↓

Networking Devices Explained: A Beginner's Guide to Routers, Switches, Hubs, and More

Vignesh J ・ Nov 15 '24

#computernetworking #beginners #webdev #interviewprep

While the Transport Layer transfers data as segments, the Network Layer sends data as packets. Let’s look at an example:

Packet Routing and Hop-by-Hop Forwarding

When sending data from A to B, it passes through several routers. Each router:

Has its own network address.
Checks if the packet is meant for it.
Uses a forwarding table to send the packet towards the destination router. This process is called hop-by-hop forwarding.

In an IP address,

Note: Routers here refer to Internet Service Provider (ISP) routers, not the ones in your home network.

Forwarding and Routing Tables

Routing Table: Contains the entire path (e.g., A → B → C → D → E).
Forwarding Table: Holds the next step (e.g., A → B).

These tables are maintained by each router.

Control Plane

The Control Plane builds routing tables. There are two types of routing:

Static Routing:
- Addresses are manually added to the routing table.
- Time-consuming and requires manual updates for network changes.
Dynamic Routing:
- Automatically updates routing tables when the network changes.

Internet Protocol (IP)

The Internet Protocol (IP) identifies routers and servers uniquely in a network. It has two versions:

IPv4 (32-bit)
IPv6 (128-bit)

IPv4

Format

IPv4 addresses are in the format X.X.X.X, where each X is an 8-bit number.

Classes of IP Addresses

Class	Range
Class A	`0.0.0.0 – 127.255.255.255`
Class B	`128.0.0.0 – 191.255.255.255`
Class C	`192.0.0.0 – 223.255.255.255`
Class D	`224.0.0.0 – 239.255.255.255`
Class E	`240.0.0.0 – 255.255.255.255`

Subnet Masking

Subnet masking divides an IP address into:

Network Section: Represents the server/network.
Host Section: Represents the client/device.

Example:

IP Address 192.168.2.30

Subnet ID: 192.168.2
Host ID: 30

Reserved Addresses

Some IPv4 addresses are reserved:

Loopback Address: 127.0.0.1 (used for testing where your device acts as both client and server).

Packets in IPv4

Packets contain headers of 20 bytes, which include:

IP version, total length, identification number, flags, protocols, checksums, addresses, and Time To Live (TTL).

The TTL ensures packets do not hop indefinitely by limiting their lifespan.You can check this by using the ping command.

IPv6

IPv6 provides a 128-bit address, significantly larger than IPv4’s 32-bit address. However, IPv6 adoption has been slow due to certain drawbacks.

Cons of IPv6

Not backward compatible: IPv4 devices cannot communicate with IPv6 networks.
High cost: ISPs require significant hardware upgrades to support IPv6.

IPv6 Format

IPv6 addresses are in the format X.X.X.X.X.X.X.X, where each X is a 16-bit hexadecimal number.

Middleboxes

Apart from end systems and routers, middleboxes also interact with IP packets. They can:

Allow or reject packets.
Modify packets.

Firewalls

Firewalls are middleboxes that act as filters:

Global Internet Firewalls: Block untrusted IP packets.
Local Network Firewalls: Protect internal networks and modify packets (e.g., changing port numbers).

Network Address Translation (NAT)

Network address translation (NAT) is a method of mapping an IP address space into another by modifying network address information in the IP header of packets while they are in transit across a traffic routing device.

That’s all for this part of the series. Stay tuned for the next part, where we’ll explore more exciting networking concepts!

Follow me on Linkedin | GitHub | Twitter

In-Depth Guide to the Transport Layer: Understanding TCP and UDP Protocols

Vignesh J — Wed, 04 Dec 2024 10:30:00 +0000

This is the sixth part of the computer networking series. Check out the previous parts if you haven’t! In this post, we’ll dive into the Transport Layer and its protocols: TCP and UDP.

What Is the Transport Layer?
How Does the Transport Layer Work?
- Data Transmission
- Congestion Control
Ensuring Data Integrity
- Checksums
- Timers
Transport Layer Protocols
- User Datagram Protocol (UDP)
- Transmission Control Protocol (TCP)
TCP’s 3-Way Handshake

What Is the Transport Layer?

The Transport Layer plays a crucial role in moving data between applications and networks.

Example

Imagine texting your friend on WhatsApp:

The Network Layer ensures your message reaches your friend’s device.
The Transport Layer ensures the data moves from the WhatsApp app on your device to the network, and then from the network to WhatsApp on your friend’s device.

How Does the Transport Layer Work?

Data Transmission

Packets: Data is divided into packets for transmission.
Multiplexing: The transport layer sends packets to the network using a multiplexer.
Demultiplexing: It receives packets from the network and sends them to the correct application.
Port Numbers: The transport layer attaches port numbers to packets for identification.

Congestion Control

The transport layer monitors network traffic to prevent congestion.

Ensuring Data Integrity

Checksums

Checksums help detect corruption during data transfer.

The sender calculates a checksum using an algorithm and sends it along with the data.
The receiver calculates a checksum for the received data.
If the checksums match, the data is intact. If not, the data is corrupted.

Timers

Timers ensure data delivery:

When a packet is sent, a timer starts.
If no acknowledgment (ACK) is received before the timer expires, the sender knows the data didn’t arrive and resends it.
Sequence Numbers: Prevent duplicate packets from causing confusion.

Transport Layer Protocols

The Transport Layer has two main protocols:

1. User Datagram Protocol (UDP)

Unreliable: Data may or may not be delivered.
Connectionless: It doesn’t establish a connection before sending data.
Error Handling: UDP uses checksums but doesn’t handle errors—it simply discards corrupted packets.
Speed: It’s faster because it doesn’t check for delivery or errors.

Applications of UDP

Video conferencing (e.g., Zoom, Teams)
DNS (Domain Name System)
Online gaming

2. Transmission Control Protocol (TCP)

Reliable: Ensures data is delivered without errors.
Connection-Oriented: Data is sent only after a connection is established.
Order Preservation: Ensures packets arrive in the correct order.
Error and Congestion Control: Checks for errors and manages network congestion.
Full Duplex: Data can be sent and received simultaneously.

How TCP Works

Segmentation:
- TCP divides large chunks of data into smaller segments, adding headers and checksums.
- At the receiver’s end, it reassembles segments into the original data.
Features:
- Error control
- Congestion control
- Sequence numbers to maintain order

TCP’s 3-Way Handshake

The 3-way handshake is a process to establish a TCP connection.

SYN: The client sends a connection request with:
- A synchronization (SYN) flag
- A random sequence number for security
SYN-ACK: The server responds with:
- A SYN flag
- An acknowledgment (ACK) flag
- A new sequence number and an acknowledgment number (client's sequence number + 1)
ACK: The client sends:
- An ACK flag
- Its updated sequence and acknowledgment numbers

Once this process is complete, a reliable connection is established.

This wraps up the Transport Layer and its protocols. Stay tuned for the next part, where we’ll dive deeper into more networking concepts!

Follow me on Linkedin | GitHub | Twitter

Understanding HTTP, Cookies, Email Protocols, and DNS: A Guide to Key Internet Technologies

Vignesh J — Sat, 30 Nov 2024 10:30:00 +0000

Introduction

This is the fifth part of the computer networking series. If you haven't read the previous parts, make sure to check them out. In this post, we'll discuss the HTTP protocol, Cookies, how email works, and the Domain Name System (DNS).

Introduction
HTTP
- HTTP Methods
- Error/Status Codes
Cookies
- Third-Party Cookies
How Email Works
- SMTP
- POP
- IMAP
Domain Name System (DNS)

HTTP

HTTP (HyperText Transfer Protocol) is a client-server protocol that defines how data is requested and sent between clients and servers.

When a client makes a request to the server, it's called an HTTP request.
When the server sends back data to the client, it's called an HTTP response.

HTTP operates at the application layer of the OSI model and uses TCP to ensure reliable data transmission.

HTTP is stateless, meaning the server doesn't store any information about the client by default.

HTTP Methods

HTTP methods indicate the action the server should take in response to a request. The most common methods are:

GET: Requests data from the server.
POST: Sends data to the server.
PUT: Replaces the current resource with the provided data.
DELETE: Deletes data on the server.

Error/Status Codes

Status codes inform the client about the result of their request.

Common Examples:

200: Request was successful.
404: Resource not found.
400: Bad request.
500: Internal server error.

Categories:

1XX: Informational responses.
2XX: Success codes.
3XX: Redirection messages.
4XX: Client errors.
5XX: Server errors.

Cookies

Cookies are unique strings stored on a client's browser by a website to track user sessions.

When you visit a webpage for the first time, a cookie is set.
On subsequent visits, the cookie is sent with the request header to maintain session states.

Third-Party Cookies

Third-party cookies are created by websites other than the one you're visiting. They are used to:

Track browsing history.
Personalize ads and services.

How Email Works

Email communication uses application layer protocols like SMTP, POP, and IMAP, with TCP ensuring reliable transport.

SMTP

SMTP (Simple Mail Transfer Protocol) handles the sending of emails.

The sender's SMTP server connects to the receiver's SMTP server.
After establishing a connection, the email is transferred.
For emails within the same domain, no external connection is needed.

Command Example:
To find SMTP servers:

nslookup -type=mx gmail.com

POP

POP (Post Office Protocol) retrieves emails from the server.

The client authorizes with credentials (email ID and password).
Emails are downloaded to the client.

IMAP

IMAP (Internet Message Access Protocol) enables viewing emails on multiple devices by keeping emails synchronized with the server.

Domain Name System (DNS)

The DNS translates domain names into IP addresses, acting as the internet's directory.

Example:
When you type google.com, the DNS resolves it to an IP address to connect your device to the server hosting Google.

Domain Hierarchy

For mail.google.com:

.com → Top-Level Domain.
google → Second-Level Domain.
mail → Subdomain.

DNS Lookup Process:

The browser first checks the local cache for the domain's IP address.
If not found, it queries the local DNS (e.g., your ISP's DNS).
If still unresolved, the request moves to root servers, top-level domains, and authoritative DNS servers to find the IP address.

Top-Level Domains (TLDs):

.com → Commercial.
.edu → Education.
.in → Country-specific.

The DNS infrastructure is managed by ICANN (Internet Corporation for Assigned Names and Numbers).

Useful Resource:
To explore root DNS servers, visit root-servers.org.

Final Words

This concludes the fifth part of the computer networking series. We've covered HTTP, Cookies, Email communication, and DNS. Stay tuned for the next part, where we'll dive deeper into more networking concepts!

Follow me on Linkedin | GitHub | Twitter

Comprehensive Guide to the OSI Model, TCP/IP Model, and Application Layer

Vignesh J — Tue, 26 Nov 2024 13:29:28 +0000

This is the fourth part of the Computer Networking series. Make sure to check the previous parts if you haven't. In this post, we’ll discuss an overview of the OSI model, TCP/IP model, and the Application Layer.

Structure of Network
- OSI Model
- TCP/IP Model
Application Layer
- Client-Server Architecture
- Peer-to-Peer Architecture
Common Protocols in Networking
Important Networking Terminologies

Structure of Network

To understand network communication and data transfer, we rely on two fundamental models:

OSI Model
TCP/IP Model

OSI Model

The Open Systems Interconnection (OSI) model has seven layers:

Application Layer
Presentation Layer
Session Layer
Transport Layer
Network Layer
Data Link Layer
Physical Layer

Each layer has its own responsibilities and interacts with the layers directly above and below it. Each layer adds specific information to ensure the data reaches its destination correctly, and these steps are reversed upon arrival.

TCP/IP Model

The Transmission Control Protocol/Internet Protocol (TCP/IP) model has four layers:

Application Layer
Transport Layer
Network Layer
Network Access Layer

The Application Layer in the TCP/IP model combines the Application, Presentation, and Session layers of the OSI model. The Network Access Layer in the TCP/IP model combines the Data Link and Physical layers of the OSI model.

Application Layer

The Application Layer is where users interact with applications like web browsers, chat applications, and more. This layer resides on our devices and provides the interface for communication.

Architectures in the Application Layer

Client-Server Architecture
Peer-to-Peer Architecture

Client-Server Architecture

The application has two parts: the client and the server, which communicate with each other as processes.
Clients are users consuming resources. For example, when you make a request to Google, you act as a client.
Servers control the websites and resources you access.
A collection of servers forms data centers, which host services, maintain static IP addresses, and require high internet speeds for efficient operation.

Peer-to-Peer Architecture

There’s no dedicated server in P2P architecture. Devices communicate directly with each other.
Each device acts as both a client and a server, making this architecture highly scalable.

Common Protocols in Networking

HTTP (HyperText Transfer Protocol): Used for browsing websites.
DHCP (Dynamic Host Configuration Protocol): Allocates IP addresses dynamically.
FTP (File Transfer Protocol): Transfers files between devices.
SMTP (Simple Mail Transfer Protocol): Sends emails.
POP3 & IMAP: Receive emails.
SSH (Secure Shell): Securely connects to remote devices.
VNC (Virtual Network Computing): Enables remote desktop sharing.
Telnet: Allows connecting to remote hosts/devices using a Telnet client (port 23).
UDP (User Datagram Protocol): A lightweight, stateless connection protocol.

Important Networking Terminologies

Let’s explain networking terms with an example: WhatsApp.

Program: The application itself (e.g., WhatsApp).
Process: A running instance or a feature of the program. For instance, sending a message or recording a video.
Thread: A lightweight version of a process. For example, when you record a video, a thread handles the camera function.
Socket: The interface between a process and the internet.
Ports:
- IP addresses identify the device making the request.
- Ports identify the application on the device.

What about multiple processes?

If multiple processes of the same application are running (e.g., multiple Chrome tabs), ephemeral ports help distinguish which specific process made the request. These are temporary network endpoints that facilitate communication between client and server applications.

This concludes Part 4. Stay tuned for the next part, where we’ll explore more aspects of computer networking!

Follow me on Linkedin | GitHub | Twitter

Networking Devices Explained: A Beginner's Guide to Routers, Switches, Hubs, and More

Vignesh J — Fri, 15 Nov 2024 05:42:15 +0000

This is the third part of the Computer Networking series! If you haven't checked out the earlier parts, make sure to do so. In this post, we’ll explore various networking devices.

Networking devices are essential components that allow devices to communicate within a network. They come in various forms and serve different purposes, such as extending network range, converting data formats, or managing traffic.

Types of Networking Devices

Internal Devices: Found inside desktops, laptops, or mobile devices, such as Ethernet, Wi-Fi cards, and Bluetooth. Disconnecting these devices affects only the specific device, as they are not shared among network users.
External Devices: Shared devices that multiple users in a network use, either directly or indirectly. Examples include routers, modems, and hubs.
Portable Devices: Battery-powered devices that create temporary networks, such as Wi-Fi hotspots. For example, you can create a hotspot with your mobile device to share your internet connection with others.

List of Networking Devices

Internal Devices

Network Interface Controller (NIC)
Wireless Network Interface Controller
Bluetooth Dongle

External Devices

Hub
Switch
Router
Brouter
Bridge
Repeater
Modem
Gateway
Wi-Fi Routers / Broadband Routers

Portable Devices

Wi-Fi Hotspot
Portable Modem Dongle

Detailed Overview of Key Networking Devices

Repeater

A Repeater extends the range of a signal to cover longer distances. It’s an electronic device that receives and retransmits signals, useful for both wired media (e.g., telephone line, fiber optic cable) and wireless media (e.g., satellite, microwave, Wi-Fi, LTE).

Modem

A Modem (Modulator-Demodulator) converts digital data from computers into analog signals for transmission over phone lines, and back into digital data at the receiving end. It modulates digital data into analog signals to send, and demodulates received analog signals into digital data for the receiving computer.

Gateway

A Gateway is a software-based device that serves as a "gate" between two networks, often found in routers with addresses like 192.168.0.1 or 192.168.1.1. A gateway enables traffic flow between networks, often acting as a firewall or router, while protecting nodes within the network.

Hub

A Hub is a basic networking device that connects multiple devices in a LAN (Local Area Network). It acts as a point of connection, allowing data to be sent to all connected devices simultaneously, though it cannot differentiate data destinations.

Switch

A Switch is a network controller that enables devices to communicate more efficiently within a network. Switches connect computers, printers, and servers in buildings or campuses, directing data to its intended destination rather than broadcasting it to all devices.

Router

A Router directs data packets between networks, finding the best path to reach the intended device on another LAN. Routers connect different networks, manage traffic, and send data across the best available paths.

Bridge

A Bridge is typically used in LANs to interconnect networks using the same protocol. It forwards data only when it knows the destination node's MAC address. While useful, bridges can potentially flood the network if they are unable to locate the destination node.

Brouter

A Brouter (Bridging Router) combines features of both bridges and routers. Operating at the data link layer, it can filter LAN traffic and route data between different networks. It acts as a router by directing packets and as a bridge by filtering LAN traffic.

Feel free to connect with me and check out my other work:

LinkedIn: Vignesh J
GitHub: Vignesh025
Twitter: vigneshtwt_

Exploring Network Types and Topologies

Vignesh J — Wed, 13 Nov 2024 07:01:28 +0000

This is the second part of the Computer Networking series. In this post, we’ll dive into different types of networks and explore various network topologies and their structures.

Personal Area Network (PAN)

A Personal Area Network (PAN) is the most basic type of computer network, designed to connect devices within a short range, typically around a single person. It allows your personal devices, like smartphones, tablets, laptops, and wearables, to communicate and share data with each other.

Local Area Network (LAN)

A Local Area Network (LAN) interconnects computers within a limited area, such as a residence, school, or university campus.

Metropolitan Area Network (MAN)

A Metropolitan Area Network (MAN) connects computers across a geographic region the size of a metropolitan area, such as a city.

Wide Area Network (WAN)

A Wide Area Network (WAN) extends over large geographic areas, such as entire countries.

In essence, multiple local area networks (LANs) connect to each other through a metropolitan area network (MAN), and several MANs are connected via a wide area network (WAN), forming the internet.

These connections are established using technologies such as:

SONET
Frame Relay

Topologies

Bus Topology

In a Bus Topology, devices are connected to a single backbone. If any part of the backbone fails, the entire system goes down. Only one device at a time can send information.

Ring Topology

In a Ring Topology, every system is connected in a ring-like structure, where each device communicates with the next. If one cable breaks, data transfer stops. This topology can lead to many unnecessary data transmissions.

Star Topology

In a Star Topology, there is a central device that connects to all computers. If the central device fails, the entire network goes down.

Tree Topology

Tree Topology is a variation of the star topology. It has a hierarchical structure resembling a tree, with a central node (root) from which other nodes branch out.

Mesh Topology

In a Mesh Topology, every device connects to every other device. This setup provides redundancy but is costly and can have scalability issues.

Hybrid Topology

Hybrid Topology combines various types of topologies. It’s used when nodes are free to take different forms. They can individually use topologies like Ring or Star, or be a combination of multiple types. Hybrid Topology offers flexibility to suit different network requirements.

Feel free to connect with me and check out my other work:

LinkedIn: Vignesh J
GitHub: Vignesh025
Twitter: vigneshtwt_

Introduction to Computer Networking: A Beginner's Guide to How the Internet Works

Vignesh J — Mon, 11 Nov 2024 13:47:24 +0000

I've recently refreshed my networking knowledge, and I often hear people saying, "I struggled with networking questions in my interview." So, I thought it would be helpful to create a blog series on Computer Networking to simplify these concepts and make it easy to review them right before interviews. This is the first and introductory part of the series, where we’ll cover the basics of networking. Let’s dive right into it!

What is a Network?
The Internet
How Did It Start?
Protocols
World Wide Web (WWW)
IP Address
- Format of an IP Address
Port Numbers
Internet Speed

What is a Network?

In simple terms, it's just computers connected together.

The Internet

The internet is essentially a collection of these computer networks.

How Did It Start?

The Advanced Research Projects Agency (ARPA) initially set up networks across four locations:

MIT
Stanford
UCLA
Utah

To enable communication between these locations, they developed ARPAnet, which used the TCP/IP protocol (we’ll discuss this in more detail later).

Protocols

Protocols are the rules established by the Internet Society on how data is sent. Examples include TCP, IP, and UDP.

World Wide Web (WWW)

The World Wide Web, commonly called the web, is an information system where documents and other resources are identified by URLs. These resources can be interlinked via hyperlinks and accessed over the internet.This is the first ever website.

IP Address

Every device on the internet that can communicate with others has an IP address.

Format of an IP Address

An IP address is typically in the format:
X.X.X.X

Each "X" can range from 0 to 255.

To check the IP address of your computer, use these commands:

Windows: ipconfig
Mac and Linux: ifconfig

You’ll come across different types of IP addresses: global and local.

Global IP Address: This is the IP address assigned by your Internet Service Provider (ISP) and is the same for all devices connected to that network.
Local IP Address: This is the unique identifier for your device within your ISP’s network.

IP addresses are assigned using Dynamic Host Configuration Protocol (DHCP).

If you’re connected to the internet through a modem, that modem assigns IP addresses to all connected devices using DHCP.

When you request data from the internet, that request goes first to your ISP, then to your modem, which uses Network Address Translation (NAT) to decide which device made the request.

Port Numbers

Now, you might wonder: even with IP addresses, how do we know which application requested the data? This is where port numbers come in.

Each port number corresponds to a specific application, allowing data to reach the correct app. For example, all HTTP requests happen on port 80.

Ports are 16-bit numbers and are divided into three ranges:

Well-Known Ports: 0–1023
Registered Ports: 1024–49151
Dynamic or Private Ports: 49152–65535

The well-known ports are system-assigned, registered ports are for specific applications, and dynamic ports are for private use. You can check a detailed list of ports here.

Internet Speed

Let’s talk about speed—not the streamer, but internet speed! A common misconception is that Mbps stands for ~~megabytes~~ per second, but it actually means megabits per second (the same applies to Kbps and Gbps).

1 Mbps = 1,000,000 bits per second

It’s a high speed, though people often underestimate it. Wondering how data transfers at such speeds? The internet doesn’t travel through air or clouds; it moves through wires and cables across oceans and land. Check out how these cables are laid at submarinecable.com.

Feel free to connect with me and check out my other work:

LinkedIn: Vignesh J
GitHub (Personal): Vignesh025
GitHub Organization (VigneshDevHub): VigneshDevHub
Join our Open-Source Community on Discord: VigneshDevHub

Technical Writing Journeys: Share Your Path to Success!

Vignesh J — Tue, 05 Nov 2024 12:08:47 +0000

Hi everyone!

I'm Vignesh, a budding writer with a passion for both technical writing and blogging. I'm eager to learn from experienced writers and improve my skills.

To gain a deeper understanding of the technical writing world, I'm reaching out to the community. I'm curious about your experiences, challenges, and triumphs.

If you're a technical writer/blogger, I'd love to hear about your journey. Please share your insights by:

1. Commenting below: Answer the questions directly in the comments section.

2. Creating a blog post about your journey: Share a link to your blog post in the comments.

Here are the questions to guide your sharing:

1. How did you get started in technical writing/blogging? What sparked your interest in this field?

2. What resources did you find most helpful in developing your technical writing/blogging skills? Were there any specific books, courses, or mentors that significantly impacted your journey?

3. What were some of the biggest challenges you faced as a technical writer/blogger? How did you overcome these obstacles?

4. What advice would you give to someone who is just starting out in technical writing/blogging? What are the essential skills and qualities to cultivate?

By sharing your experiences, you'll inspire aspiring writers like me and help shape the future of technical communication.

Let's connect and learn together!

Feel free to connect with me and check out my other work:

LinkedIn: Vignesh J
GitHub (Personal): Vignesh025
Join our Open-Source Community on Discord: VigneshDevHub

Looking forward to your support!