DEV Community: Aayush Singh

Diving into RDBMS & Data Integrity

Aayush Singh — Sun, 13 Jul 2025 17:45:14 +0000

This blog is the second part of my series on learning Database Management Systems (DBMS). In the first blog, I covered the basics of DBMS, and in this post, we will delve into the details of Relational Database Management Systems (RDBMS). I highly encourage you to read my previous blog before continuing with this one. So let’s get started!😁

What is RDBMS?

A Relational Database Management System (RDBMS) is a type of database management system that stores data in the form of tables (also called relations). Each table consists of rows (records) and columns (attributes), and the data is organized so that relationships between different tables can be easily established using keys.

Real-life Analogy

Think of an RDBMS like an Excel workbook where each sheet (table) holds data about a specific topic (like students, courses, teachers). You can link different sheets using common columns like Student_ID or Course_ID — this linking is what makes it "relational."

Key Features of RDBMS

Uses tables to store structured data
Supports primary keys and foreign keys to enforce data integrity
Allows SQL querying for data manipulation
Supports normalization to remove redundancy
Ensures data consistency and integrity

Relational Terminologies

Before diving deeper into relational databases, it's important to understand some basic terms used in RDBMS. These terms describe how data is structured and organized inside a relational database.

Relation (Table)
A relation is simply a table in an RDBMS. It represents a collection of related data entries and consists of rows and columns. Each relation has a unique name and stores data about a particular type of object or entity.
Example: A Student table is a relation that holds data about students.
Tuple (Row / Record)
A tuple is a single row in a table. It represents one complete set of related data or a record.
Example: A single row in the Student table that stores data of one student is a tuple.
Cardinality
Cardinality refers to the number of tuples (rows) in a relation.
Example: If there are 50 students in the Student table, its cardinality is 50.
Attribute (Column /Field)
An attribute is a column in a table. It describes a specific property or characteristic of the data stored in each row. Attributes are also referred to as fields.
Example: In a Student table, columns like Student_ID, Name, and Age are attributes.
Domain
A domain refers to the set of valid values an attribute can take. For example, the domain of the Age attribute could be all integer values from 15 to 100.
Degree
Degree is the number of attributes (columns) in a relation.
Example: If the Student table has 4 columns (Student_ID, Name, Age, Email), then its degree is 4.

Properties of Relational tables

Cells contains atomic values
Values in a column are of the same kind
Each row is unique
No two tables can have the same name in a relational schema.
Each column has a unique name
The sequence of rows is insignificant
The sequence of columns is insignificant.

Data Anomalies

When a database is not properly structured, it can lead to data anomalies — unexpected issues that arise when inserting, updating, or deleting data. These problems often occur when all the data is stored in a single large table instead of being divided into related tables.

Why Do Data Anomalies Occur?

Data anomalies typically occur when:

A table has repeated data (redundancy)
Multiple types of data are stored together (like student + course + teacher in one table)
The database is not normalized, meaning it hasn't been structured properly into separate tables with relationships

Types of Data Anomalies

Insertion Anomaly
Occurs when you can’t insert data into a table without inserting something else unnecessarily.
Example: If a new course is being introduced but no students have enrolled yet, you can't insert the course without leaving student-related fields blank.
Update Anomaly
Occurs when the same piece of data is stored in multiple places, and not all copies are updated correctly.
Example: If a teacher's name is updated in one row but not in others, the database now holds inconsistent data.
Deletion Anomaly
Occurs when deleting one piece of data accidentally removes other useful information.
Example: If the last student enrolled in a course is deleted from the table, the course information may also get deleted.

How to Solve Data Anomalies?

The most effective way to solve data anomalies is by using Normalization. It is a process that involves:

Splitting large tables into smaller, related tables
Removing redundancy
Organizing data into logical groupings

We’ll explore normalization and normal forms (1NF, 2NF, 3NF, BCNF) in upcoming sections of this blog.

Functional Dependencies (FDs)

In relational database design, Functional Dependency (FD) is a very important concept that helps us understand how attributes (columns) relate to one another. It forms the foundation of normalization.

What is a Functional Dependency?

A Functional Dependency exists when the value of one attribute uniquely determines the value of another attribute in a relation (table).

Let’s say we have a relation R, and attributes A and B. We say:
A → B (A functionally determines B)
This means: if two rows have the same value for attribute A, they must have the same value for attribute B.

Simple Example

Consider a Student table:

Student_ID	Name	Course
101	Alice	DBMS
102	Bob	OS
101	Alice	DBMS

Here:

Student_ID → Name Because if Student_ID is the same, the Name must also be the same.
But Name → Student_ID is not valid, because two students can have the same name.

Why Functional Dependencies Matter

They help us find candidate keys
They guide table splitting in normalization
They help eliminate data redundancy and anomalies

Attribute Closure

Attribute closure of a set of attributes X, denoted as X⁺, is the set of all attributes that can be functionally determined from X using the given set of functional dependencies.

It helps you check if a set of attributes is a super key
It helps you determine the minimal cover of FDs
It is used in finding candidate keys during schema design

Step-by-Step Example

Let’s say we have a relation R(A, B, C, D)
And the functional dependencies (FDs) are:

A → B
B → C
A → D

Let’s find the closure of A (A⁺):

Step 1: Start with A⁺ = {A}
Step 2: A → B → add B ⇒ A⁺ = {A, B}
Step 3: B → C → add C ⇒ A⁺ = {A, B, C}
Step 4: A → D → add D ⇒ A⁺ = {A, B, C, D}

So, A⁺ = {A, B, C, D}

That means A is a super key, because it determines all attributes in the relation.

General Algorithm to Find Closure

Start with X⁺ = X (initial set)
Repeatedly apply all FDs where:

If Y → Z and Y ⊆ X⁺, then add Z to X⁺
1. Stop when no more attributes can be added

Armstrong’s Axioms

Armstrong’s Axioms are a set of rules or inference laws used to derive all valid functional dependencies from a given set. These rules are sound and complete, meaning they will only derive correct FDs and can derive all correct FDs.

They form the theoretical foundation for reasoning about functional dependencies in relational databases.

Why Do We Need Armstrong’s Axioms?

To generate new functional dependencies from a known set
To prove whether a particular FD holds
To simplify and minimize functional dependencies
To help in finding candidate keys and in normalization

Core Armstrong’s Axioms (3 Basic Rules)

Reflexivity
If Y is a subset of X, then X → Y
Example: If X = {A, B}, then X → A and X → B are valid
Augmentation
If X → Y, then XZ → YZ (add same attributes to both sides)
Example: If A → B, then AC → BC
Transitivity
If X → Y and Y → Z, then X → Z
Example: If A → B and B → C, then A → C

Additional (Derived) Rules

Using the core axioms, we can derive more useful rules:

Union: If X → Y and X → Z, then X → YZ
Decomposition: If X → YZ, then X → Y and X → Z
Pseudo-Transitivity: If X → Y and YZ → W, then XZ → W

These are not part of the original axioms but can be proved using them.

Summary Table

Axiom	Rule Description	Example
Reflexivity	If Y ⊆ X, then X → Y	AB → A
Augmentation	If X → Y, then XZ → YZ	A → B ⟹ AC → BC
Transitivity	If X → Y and Y → Z, then X → Z	A → B, B → C ⟹ A → C
Union	If X → Y and X → Z, then X → YZ	A → B, A → C ⟹ A → BC
Decomposition	If X → YZ, then X → Y and X → Z	A → BC ⟹ A → B, A → C
Pseudo-Transitivity	If X → Y and YZ → W, then XZ → W	A → B, BC → D ⟹ AC → D

When to Use Armstrong’s Axioms

During attribute closure calculation
To simplify or minimize a set of FDs
To prove whether an FD logically follows from a given set

Keys in RDBMS

In relational databases, keys are crucial because they help uniquely identify rows (tuples) and maintain data integrity. Without keys, it would be difficult to retrieve, relate, or update data accurately.

What is a Key?

A key is one or more attributes (columns) that can uniquely identify a record in a table.
Different types of keys serve different purposes in database design.

Types of Keys in RDBMS

Super Key
A super key is any set of attributes that can uniquely identify a tuple (row) in a table.
It may contain extra (redundant) attributes.
Example: {Student_ID}, {Student_ID, Email}
Candidate Key
A minimal super key — meaning it uniquely identifies a record, and if you remove any attribute, it no longer does.
A table can have multiple candidate keys.
Example: {Student_ID}, {Email} (if both are unique)
Primary Key
One of the candidate keys is selected as the primary key.
It cannot have NULL values and must be unique for each row.
Example: Student_ID is chosen as the primary key
Alternate Key
A candidate key not chosen as the primary key is called an alternate key.
Example: If Email is a candidate key but not the primary key, it’s an alternate key.
Composite Key
A key that consists of two or more attributes that together uniquely identify a record.
Example: In a Student_Course table, the combination of Student_ID and Course_ID can form a composite key.
Foreign Key
A foreign key is an attribute in one table that refers to the primary key of another table.
It is used to establish a relationship between two tables.
Example: Department_ID in the Employee table refers to the Department table.

Summary Table

Key Type	Description	Example
Super Key	Any set of attributes that uniquely identifies a row	`{Student_ID, Email}`
Candidate Key	Minimal super key (no redundant attributes)	`{Student_ID}`, `{Email}`
Primary Key	Chosen candidate key; cannot be null	`Student_ID`
Alternate Key	Candidate key not selected as primary key	`Email`
Composite Key	Key formed by combining two or more attributes	`{Student_ID, Course_ID}`
Foreign Key	Attribute linking to primary key of another table	`Department_ID` in `Employee`

Normalization & Normal Forms

When a database is poorly structured, it can suffer from problems like data redundancy, update anomalies, and inconsistency. This is where normalization comes in.

Normalization?

Normalization is a process in relational database design that organizes data into well-structured tables to minimize redundancy and avoid anomalies.
It involves dividing a large table into smaller, related tables and defining relationships between them.

Why Normalize?

To eliminate duplicate data
To reduce insertion, update, and deletion anomalies
To maintain data integrity
To make the database easier to maintain

Normal Forms

Normalization is done through a series of normal forms — each with specific rules. Let's understand the first three main normal forms (commonly used in practice):

First Normal Form (1NF)
- A table is in 1NF if:
- All values in each column are atomic (indivisible)
- There are no repeating groups or arrays
- Example: A student should not have multiple phone numbers stored in a single column like 12345, 67890. Instead, store them in separate rows.
Second Normal Form (2NF)
- A table is in 2NF if:
- It is already in 1NF
- Every non-prime attribute is fully functionally dependent on the entire primary key
- Mainly applies to composite keys
- Removes partial dependency
- Example: In a Student_Course table with primary key (Student_ID, Course_ID), Student_Name should not depend only on Student_ID.
Third Normal Form (3NF)
- A table is in 3NF if:
- It is already in 2NF
- There is no transitive dependency between non-key attributes
- Removes dependencies like: A → B, B → C, so A → C (which is transitive)
- Example: In a table where Student_ID → Department_ID and Department_ID → Department_Name, you should split the tables to avoid storing Department_Name repeatedly.
Boyce-Codd Normal Form (BCNF)
- A stricter version of 3NF
- Every determinant must be a candidate key

Summary

Normal Form	Key Rules	Purpose
1NF	Atomic values, no repeating groups	Basic structure
2NF	No partial dependency on composite keys	Eliminates redundancy
3NF	No transitive dependency among non-key attributes	Ensures clear relationships
BCNF	Every determinant is a candidate key	Advanced, strict 3NF

Indexing in RDBMS

As your database grows, searching for data can become slow. This is where indexing comes into play. It helps make data retrieval faster — just like how an index in a book helps you find topics quickly.

What is Indexing?

Indexing is a database technique used to speed up data retrieval operations on a table.
An index is a data structure (usually a B-tree or hash) that allows the database to find rows more quickly without scanning the entire table.

Why Use Indexing?

Speeds up SELECT queries significantly
Helps in sorting and searching large datasets
Improves performance when using WHERE, JOIN, ORDER BY, etc.

Real-Life Analogy

Think of a database table as a book and an index as the table of contents. Without an index, you would have to flip through every page to find what you need. With an index, you can go directly to the right page.

Types of Indexes

Primary Index
Created automatically on the primary key. Ensures uniqueness and fast lookup.
Secondary Index
Created manually on non-primary key columns to improve performance.
Composite Index
An index on multiple columns. Useful when queries filter on more than one column.
Clustered Index
Sorts the actual data rows according to the index. A table can have only one clustered index.
Non-Clustered Index
Stores pointers to the data instead of sorting it. A table can have multiple non-clustered indexes.

Things to Keep in Mind

Indexes speed up reads but can slow down writes (INSERT, UPDATE, DELETE)
Over-indexing can waste storage and affect performance
Use indexing strategically for frequently queried columns

Summary

Type of Index	Description	Use Case
Primary Index	Automatically created on primary key	Uniquely identify rows
Secondary Index	Manually created on other columns	Improve query speed
Composite Index	On multiple columns	Queries involving multiple conditions
Clustered Index	Sorts actual data rows	Faster range queries
Non-Clustered Index	Stores pointers to rows	Multiple fast lookups on big tables

Thanks For Reading 🤗

Introduction to DBMS: Why and How We Store Data

Aayush Singh — Mon, 30 Jun 2025 17:13:57 +0000

DBMS, or Database Management System, is a fundamental concept in the world of data handling and software systems.
Before we dive deep into this topic, let’s first understand some basic terminologies that will give you a clear picture of what DBMS is and why it matters.

Basic Terminologies

Data — Raw facts and figures without any context, such as numbers, text, or symbols stored in a database.
Information — Processed and organized data that is meaningful and useful for decision-making.
Database — A structured collection of data that enables easy access, management, and updates. It is generally stored and accessed electronically from a computer system.
Database Management System (DBMS) — Software that facilitates efficient storage, retrieval, and management of data within a database.

Why Use a DBMS?

You might be wondering: Why DBMS? Why not store data in a file system or even in an Excel sheet?

The reason lies in the powerful features that a DBMS offers:

It supports data querying, reporting, and analytics to enable informed decision-making.
It provides structured querying capabilities, allowing for faster and more efficient data access.
It ensures data integrity, consistency, and security, which are hard to manage in a plain file system.

Three Views of a Database in DBMS

1. Internal View (Physical Level)

This is the lowest level of abstraction that defines how the data is physically stored in memory (files, indexes, etc.). This level is managed by the DBMS and is invisible to users and even most developers.

2. Conceptual View (Logical Level)

This level shows the logical structure of the entire database — what data is stored and how different data items relate to each other. This level is maintained by database administrators and is common for all users. It hides the internal view but reveals how data is logically organized.

3. External View (View Level)

This is the highest level of abstraction, showing only a part of the database that a specific user or application needs. Different users can have different external views, depending on their roles or permissions.

Data Independence

Data Independence is the ability to change the structure of a database at one level without affecting the structure at the next higher level. It ensures that changes in how data is stored (physical level) or how it's organized (logical level) do not force changes in the applications using that data.
There are two types of data independence:

Logical Data Independence – changing the logical schema without affecting external views.
Physical Data Independence – changing physical storage without affecting the logical schema.

Instance and Schemas

Instance - An instance is the actual content or data stored in the database at a particular moment in time. An instance changes frequently as data is inserted, updated, or deleted.
Schemas - A schema is the overall design or structure of the database — it defines how the data is organized, including tables, fields, relationships, and constraints. The schema is defined once when the database is created and usually does not change frequently.

Types of Data Bases

Databases come in different types based on how data is stored, organized, and accessed. Here are some of the most common types:

1.Relational Database - Stores data in tables (rows and columns) with relationships between them using keys.

Example: MySQL, PostgreSQL, Oracle.

Use Case: Banking systems, inventory management, e-commerce websites.

Analogy: Like an Excel spreadsheet where rows are records and columns are fields.

2.Hierarchical Database - Stores data in a tree-like structure with parent-child relationships.

Example: IBM Information Management System (IMS).

Use Case: File systems, legacy applications.

Analogy: Like folders inside folders on your computer.

3.Network Database - Similar to hierarchical but allows many-to-many relationships between records using graph-like structure.

Example: Integrated Data Store (IDS), CODASYL.

Use Case: Telecom and complex network applications.

Analogy: Like a web where one page can link to many others and vice versa.

4.Object-Oriented Database - Stores data in the form of objects, like in object-oriented programming.

Example: db4o, ObjectDB.

Use Case: Applications using C++, Java, Python with complex data types.

Analogy: Like storing not just the data, but also the behavior (methods) of the object.

5.Document-Oriented (NoSQL) Database - Stores data as documents (usually JSON or XML), allowing flexible schema.

Example: MongoDB, CouchDB.

Use Case: Real-time analytics, content management systems, modern web apps.

Analogy: Like folders of dynamic, self-contained documents.

6.Columnar Database - Stores data column-wise instead of row-wise for faster analytics.

Example: Apache Cassandra, HBase.

Use Case: Big Data analytics, data warehousing.

Like flipping a spreadsheet and focusing on one column at a time for analysis.

7.Key-Value Store - Stores data as key-value pairs, great for fast lookups.

Example: Redis, DynamoDB.

Use Case: Caching, session storage, high-speed real-time systems.

Analogy: Like a dictionary where each word (key) has a definition (value).

Beside them a new and growing class of databases tailored for semantic and AI-driven workloads is evolving which is called as Vector Databases. Vector Databases Stores and queries high-dimensional embeddings using ANN indexing (e.g., Pinecone, Milvus, Chroma). Especially useful for semantic search, AI retrieval (RAG), image/text similarity . While they stand alongside relational, NoSQL, and graph databases, their ability to combine with other models places them firmly in the evolving landscape of multi-model/hybrid databases.

ER Diagram

An ER (Entity-Relationship) Diagram is a visual representation of the data and the relationships between different entities in a database. It helps in designing a database by showing entities (like tables), their attributes (fields), and how they are connected.

Entity

An Entity is a real-world object or concept that can be distinctly identified and has data stored about it in a database. Each entity has attributes (properties) that describe it.

Example: In a school database, entities can be Student, Teacher, or Course.

There are two types of entity

Tangible- Entities which physically exist in real world. E.g. - Car, Pen, locker.
Intangible- Entities which exist logically. E.g. – Account, video.

In ER diagram we cannot represent an entity, as entity is an instant not schema, and ER diagram is designed to understand schema. In a relational model entity is represented by a row or a tuple or a record in a table.

Entity set

An entity set is a collection of similar types of entities (i.e., multiple entities of the same kind stored together in a table). An entity set is the entire table — all the rows (entities) that represent the same type of thing. Just like a "Student" table is an entity set made up of many "Student" entities.

Based on the above table

"John" is one entity.
"Marry" is another entity.

Together, they belong to the Customer entity set.

Attributes

An attribute is a property or characteristic of an entity. In databases, attributes are represented as columns in a table. If an entity is a row, then each attribute is a column that stores information about that row.

Here are the attributes of the above customer entity set CustomerID, FirstName, LastName, BirthDate. Each column is an attribute, and it holds a specific piece of information about every customer.

In an ER diagram attributes are represented by ellipse or oval connected to rectangle.

While in a relational model they are represented by independent column. e.g. EmpNo, EmpName, Salary

Types of Attributes

Simple Attribute - Cannot be divided further. eg: Age, Email

Think of it as: One solid value.
Composite Attribute - Can be divided into smaller parts. eg: Name → can be split into First Name and Last Name

Think of it like: Full Name = First Name + Last Name
Derived Attribute - Can be calculated from other attributes. eg: Age can be derived from Date of Birth

Think of it like: Not stored directly, just calculated when needed.
Single-valued Attribute - Holds only one value per entity. eg: Student_ID, Date of Birth

Just a regular field, not a list
Multi-valued Attribute - Can have multiple values for one entity. eg: Phone Numbers (a student can have more than one)
Key Attribute - Uniquely identifies an entity (usually the Primary Key) eg: Student_ID

It's the ID card of each row

Relationship / Association

A relationship in DBMS is an association between two or more entities. It shows how entities are connected or related to each other in the real world.
If an entity is a table (like Student or Course), then a relationship shows how those tables are connected — for example, which student is studying which course.

Example:

Entities: Student, Course
Relationship: Study

📊 In an ER diagram, relationships are shown as diamonds, with lines connecting the related entities. While in relational model
sometimes through foreign key and other time by a separate table.

Component of Relationships.

In an ER (Entity-Relationship) diagram, a relationship connects two or more entities. But every relationship is more than just a connection — it has important components that describe how it works. Let’s understand the three main components of a relationship:

Name - The name simply identifies what the relationship means or represents in real life. For example: In a school database, the relationship between Student and Course can be named "Enrolled" — indicating which student is enrolled in which course. A meaningful name makes your ER diagram easy to read and understand. It's like labeling arrows in a flowchart. Every relation must have a unique name.
Degree – It can be defined as the number of entity sets (relations/tables) associated (participating) in the relationship set. Most of the relationship sets in a database system are binary. Occasionally, however, relationship sets involve more than two entity sets. In short, the degree tells us how many entities are connected and helps in choosing the right design structure. It has three types:
- Unary Relationship – One single entity set participates in a relationship, meaning two entities of the same entity set are related to each other. Example: A member in a team may be the supervisor of another member in the same team.
- Binary Relationship – Two entity sets participate in a relationship. It is the most common type of relationship. Example: Student enrolled in Course.
- Ternary Relationship – Three different entity sets participate in a single relationship. It is used when a relationship logically requires all three entities. Example: A Doctor prescribes a Medicine to a Patient.
Structural constraints (Cardinalities Ratios, Participation) – These constraints define the rules of how entities participate in relationships. They help in understanding the nature of the relationship between entities and are mainly of two types:
- Cardinality Ratios – This defines the number of instances of one entity that can be associated with instances of another entity. It determines the type of relationship:
  - One-to-One (1:1) – One instance of an entity A is related to at most one instance of entity B, and vice versa. Example: One person has one passport.
  - One-to-Many (1:N) – One instance of entity A is related to multiple instances of entity B, but one instance of B is related to only one instance of A. Example: One teacher teaches many students.
  - Many-to-One (N:1) – Many instances of entity A are related to one instance of entity B. Example: Many employees work in one department.
  - Many-to-Many (M:N) – Many instances of entity A can be related to many instances of entity B. Example: Students enroll in many courses and courses have many students.
- Participation – It defines whether all entities in an entity set must participate in a relationship or not. It is of two types:
  - Total Participation – Every instance of the entity set must participate in the relationship. Example: Every employee must belong to at least one department.
  - Partial Participation – Some instances of the entity set may not participate in the relationship. Example: Some students may not enroll in any course.

Advantages of ER Diagrams

Simple and Clear Visualization – ER diagrams provide a graphical representation of entities, relationships, and attributes, which makes database design easier to understand.
Helps in Logical Database Design – They are excellent tools for planning and organizing database structures before implementation.
Improves Communication – ER diagrams help developers, database designers, and stakeholders communicate and collaborate effectively.
Error Detection – It becomes easier to identify inconsistencies, missing entities, or unnecessary relationships at an early stage.
Documentation Purpose – ER diagrams serve as useful documentation for maintaining and updating the database over time.

Disadvantages of ER Diagrams

Not Suitable for Complex Logic – They are not ideal for representing complex constraints or business logic like triggers or stored procedures.
Scalability Issues – For very large systems, ER diagrams can become overly complex and hard to manage or read.
No Standard Symbols – Different organizations or tools may use different notations, which can create confusion.
Lack of Support for Some Data Models – ER diagrams are primarily used for relational databases and may not represent NoSQL or object-oriented models effectively.
Loss of information content

What’s Next?

Now that we've covered the basics in this blog, get ready to dive deeper!
In the next blog, we’ll explore Relational Database Management Systems (RDBMS) and break down some complex concepts in a simple and beginner-friendly way.

To stay updated with the series, follow me on X and LinkedIn.

Thank you for reading!

Let’s Talk to the Internet: Understanding the Application Layer

Aayush Singh — Sun, 13 Apr 2025 10:10:59 +0000

Welcome back to our final blog in the Computer Networking for Beginners series! So far, we’ve taken a journey from the Physical Layer all the way up to the Transport Layer. Now, it's time to explore the top-most layer that interacts directly with us—the users.

Let’s dive into the Application Layer — the layer where everything we do online actually begins and ends.

What is the Application Layer?

The Application Layer is the 7th and final layer of the OSI model. It’s the part of the network that users interact with directly. Whenever you browse a website, send an email, or upload a photo, you’re using the Application Layer.

Think of it like the cashier counter at a supermarket—after all the backend operations (stocking, billing system, barcodes, etc.), it’s where you interact directly.

- Position in OSI Model: Top layer

- Position in TCP/IP Model: Merged with Presentation and Session Layers

Role of the Application Layer

The Application Layer provides services directly to user applications. It allows software like browsers, email clients, and messaging apps to communicate over the network.

It does not define the actual application (like Chrome or WhatsApp), but rather the protocols and services that applications use to communicate.

Key Responsibilities:

Identify communication partners
Determine resource availability
Synchronize communication

Popular Application Layer Protocols

Here are some common protocols you’ve probably used without even realizing it:

HTTP / HTTPS

Used for web browsing.

Example: When you visit a website, your browser uses HTTP/HTTPS to fetch data.

FTP / SFTP

Used to transfer files over the internet.

Example: Uploading or downloading files to/from a server.

SMTP, POP3, IMAP

Used for sending and receiving emails.

Example: Gmail uses these to send and sync your emails.

DNS

Translates domain names to IP addresses.

Example: Typing www.google.com gets converted to an IP behind the scenes.

DHCP

Automatically assigns IP addresses to devices on a network.

🌐 The World Wide Web (WWW)

The World Wide Web (WWW) is one of the most common ways users interact with the Application Layer. It’s the system of interlinked documents and resources that we access using the internet — through web browsers, websites, and online services.

Let’s explore the key components that make the web work:

HTTP, HTTPS, URL, Browser, DNS, Client-Server Model, and Cookies.

HTTP (HyperText Transfer Protocol)

HTTP is the protocol used for transferring web pages over the internet. When you visit a website, your browser sends an HTTP request to the server, and the server sends back an HTTP response with the requested page.

Example: Typing http://example.com tells the browser to use HTTP to fetch the page from the server.

HTTPS (HTTP Secure)

HTTPS is a secure version of HTTP that uses encryption (SSL/TLS) to protect data during transmission. It ensures that your data (like login info or payment details) cannot be read or tampered with by attackers.

🔒 Sites with HTTPS show a lock symbol in the browser — meaning your connection is secure.

URL (Uniform Resource Locator)

A URL is the web address you type in the browser. It tells the browser what protocol to use, which server to contact, and what resource to fetch.

Example Breakdown:

https://www.example.com/about

https → Protocol
www.example.com → Domain name
/about → Resource path

Browser

A browser is a client application (like Chrome, Firefox, or Safari) that lets users access and interact with websites. It uses HTTP/HTTPS to communicate with servers and displays the content (HTML, CSS, JS) to the user.

Browsers also manage cookies, cache, and security settings.

DNS (Domain Name System)

DNS is like the phonebook of the internet. It translates domain names like www.google.com into IP addresses like 142.250.182.4 — which are needed to locate servers.

Without DNS, users would have to remember IP addresses instead of easy-to-remember domain names.

Client

The client is the device or software (like a browser) that initiates a request. In the web world, your browser acts as the client when you visit a website.

Clients send requests and wait for responses from servers.

Server

The server is a powerful computer that stores website data. It receives requests from clients and sends back responses — like web pages, images, or data.

Example: When you visit www.netflix.com, your browser (client) talks to a Netflix server to fetch videos or show your dashboard.

Cookies

Cookies are small text files stored by the browser on your device. They help websites remember you and your preferences.

Examples of cookie usage:

Keeping you logged in
Saving language or theme preferences
Tracking site usage (analytics)

Cookies can be secure, HttpOnly, and encrypted to enhance privacy.

Cache

Cache is a temporary storage used by browsers to store copies of previously accessed data (like images, scripts, or entire web pages) so that future requests for that data can be served faster.

Think of it like a shortcut — instead of re-downloading the same logo or webpage each time, your browser saves a copy and loads it locally.

Example:
When you visit a news site, the logo and stylesheets are cached by your browser. Next time you visit, the browser doesn’t ask the server again — it loads them directly from your local cache.

Fun Fact:
Sometimes, outdated cache can cause a page to not show the latest changes. That’s why we hit Ctrl + Shift + R (Hard Refresh) to force the browser to reload everything fresh.

This entire system — involving clients, servers, DNS, HTTP/HTTPS, URLs, and browsers — works together to bring websites and web apps to life. All of these live at the Application Layer, making the WWW a real-world application of networking concepts.

Real-World Analogy: Visiting a Website

Let’s say you open your browser and go to www.example.com:

Your browser uses DNS to find the IP address of the website.
It then uses HTTP or HTTPS to send a request to that IP.
The website responds, and the page is displayed.

All this magic happens through protocols in the Application Layer!

Application Layer in OSI vs TCP/IP Model

In the OSI Model, the Application Layer is separate from the Presentation and Session layers.

But in the TCP/IP Model, these three are combined into one Application Layer.

So:

OSI: Application + Presentation + Session  
TCP/IP: Application Layer (combined)

Application Layer Security Basics

The Application Layer is also where security matters most to users. Here are some security concepts:

HTTPS: Secures communication between browser and website
Authentication: Verifying users before granting access
Encryption: Protects data from eavesdropping

These ensure safe communication over the internet.

Conclusion

The Application Layer is like the front door to the internet — it’s what users actually experience. Whether you're browsing websites, streaming videos, sending emails, or chatting online, it all happens here.

In this blog, we explored the real-world technologies like HTTP, HTTPS, DNS, URLs, browsers, cookies, and cache that bring the World Wide Web to life. Understanding this layer gives you a new appreciation for everything you do online.

🎉 With this, we wrap up our 6-part beginner-friendly blog series on Computer Networking.

A huge thank you to everyone who held on through the series — from the basics and physical layer all the way to the application layer. I hope it made networking simpler and more fun for you!

I'll continue posting new blogs in the coming days — on different tech topics to help you learn and grow.

If you found this blog helpful, share it with your friends, leave a comment below, or follow me here:

👉 LinkedIn

👉 Twitter

Stay curious, keep learning, and explore the web with confidence! 🌐🚀

How the Transport Layer Bridges the Gap Between Applications and Networks

Aayush Singh — Sun, 30 Mar 2025 11:13:04 +0000

Welcome back, tech explorers! 🚀

I’m glad to have you here as we continue our exciting journey through the world of computer networking. If you haven’t checked out the previous blogs in this series—where we explored the Physical, Data Link, and Network layers—I highly recommend giving them a read. They’ll help you build a solid foundation before diving into today’s topic.

Now, let’s move one step higher in the networking hierarchy and uncover the magic of the Transport Layer—the unsung hero ensuring smooth and reliable communication between devices. Let’s get started! 🎯

Introduction

Imagine you’re sending a package to a friend in another city. You carefully pack it, choose between a reliable courier service (which guarantees delivery with tracking) or a faster, no-tracking option, and label it with the correct address. The transport layer in networking works in a similar way—it ensures that data sent from one device reaches the right application on another device, either reliably or quickly, depending on the need.

Key Functions of the Transport Layer

Segmentation & Reassembly (Breaking down data into smaller packets and reassembling them).
Flow Control (Preventing data overload using mechanisms like sliding window).
Error Control (Ensuring data integrity through acknowledgments and retransmissions).
Multiplexing & Demultiplexing (Managing multiple communication sessions).

How Does It Work?

When an application sends data, the transport layer divides it into smaller units called segments (in TCP) or datagrams (in UDP). Each segment is labeled with a source port number and a destination port number, so the receiver knows which application should process the data.

Protocols of the Transport Layer

The two main protocols in this layer are:

TCP (Transmission Control Protocol) – A reliable, connection-oriented protocol that guarantees data delivery with error checking, acknowledgments, and retransmissions if needed. Think of it like a courier service with tracking.
UDP (User Datagram Protocol) – A fast, connectionless protocol that sends data without guarantees. It’s useful for time-sensitive applications like gaming and streaming. Think of it like sending a postcard—quick but no guarantee it’ll arrive safely.

Ports & Port Numbers

Every computer has multiple applications running at the same time—so how does the transport layer know where to send the data? That’s where port numbers come in. A port is like a specific door in a building that directs incoming data to the right application. For example:

Port 80 – Used for HTTP (web browsing)
Port 443 – Used for HTTPS (secure web browsing)
Port 25 – Used for email (SMTP)

We are done with introduction part, I think i described everything in concise format now let's discuss everything in detail.

Transport layer protocol

Transmission Control Protocol (TCP) – Reliable & Connection-Oriented

TCP is like a well-organized courier service that guarantees your package (data) will reach its destination correctly and in order. It establishes a connection between sender and receiver before transmitting data, making sure that the communication is reliable and accurate.

Key Features of TCP:

Connection-Oriented – A connection is established before sending data (via a process called the three-way handshake).
Reliable Delivery – Ensures that all data reaches the destination correctly. If a packet is lost, TCP retransmits it.
Error Checking – Uses checksums to detect errors in transmission.
Ordered Data Transfer – TCP numbers each packet so they arrive in the correct order.
Flow Control – Prevents overwhelming the receiver by adjusting the speed of data transmission.
Congestion Control – Regulates data flow to avoid network congestion.

How TCP Works?

1 Connection Establishment (Three-Way Handshake)

The sender sends a SYN request to initiate communication.

The receiver responds with SYN-ACK to acknowledge the request.

The sender replies with ACK, and the connection is established.

2 Data Transmission

TCP segments are sent in sequence, and each segment is acknowledged by the receiver.

If a segment is lost, TCP retransmits it.

3 Connection Termination

When communication is done, the sender and receiver exchange FIN (Finish) and ACK packets to close the connection.

TCP Header

When data is transmitted using TCP, it is broken into segments, and each segment contains a TCP header. This header provides important control information that ensures reliable and ordered delivery of data.

The TCP header is typically 20 to 60 bytes long and contains the following fields:

Source Port & Destination Port – These ensure the data is sent to the correct application. For example, a web server may use port 80 (HTTP), while an email server may use port 25 (SMTP).
Sequence Number – TCP assigns each byte of data a sequence number, ensuring that data is reassembled correctly at the receiver’s end.
Acknowledgment Number – This field confirms receipt of data. If a sender sends data with sequence number 1000, the receiver will reply with acknowledgment 1001, meaning it expects the next byte to start from 1001.
Flags (Control Bits) – Used to manage the connection:

SYN – Used in connection establishment (Three-Way Handshake).

ACK – Acknowledges received data.

FIN – Used to terminate a connection.

RST – Resets the connection.

URG – Indicates urgent data.

PSH – Instructs to send data immediately.

Window Size – Controls flow control by specifying how much data can be sent before requiring an acknowledgment.
Checksum – Used for error detection to ensure data integrity.
Urgent Pointer – If the URG flag is set, this field tells the receiver which part of the data is urgent.

Use Cases of TCP:

Web Browsing (HTTP/HTTPS) – Ensures webpages load completely and correctly.
Email (SMTP, IMAP, POP3) – Guarantees reliable delivery of emails.
File Transfer (FTP) – Ensures error-free transmission of files.

User Datagram Protocol (UDP) – Fast & Connectionless

UDP is like sending a regular letter without tracking—it delivers data quickly but does not guarantee that all packets will arrive. It does not establish a connection before sending data, making it much faster than TCP.

Key Features of UDP:

Connectionless Communication – No need to establish a connection before sending data.
Fast & Lightweight – Less overhead compared to TCP.
No Error Checking or Retransmission – Lost packets are not resent.
Unordered Data Transfer – Packets may arrive out of order.

How UDP Works?

The sender transmits data packets (datagrams) to the receiver.
The receiver gets them, but there are no guarantees of order or reliability.
If a packet is lost, UDP does not request retransmission.

UDP Header

Unlike TCP, UDP (User Datagram Protocol) does not establish a connection before sending data, making it faster but less reliable. The UDP header is fixed at 8 bytes, making it much smaller than the TCP header.

Source Port & Destination Port – Like TCP, these identify the sender and receiver’s applications. For example, a video streaming service might use port 1935 (RTMP), and DNS uses port 53.
Length – Specifies the total length of the UDP packet (header + data). The minimum size is 8 bytes (header only), but it can be larger if data is included.
Checksum – Provides error detection. Unlike TCP, UDP does not request retransmission if errors are found, meaning the data is simply discarded.

Use Cases of UDP:

🔹 Online Gaming – Fast response time is more important than 100% accuracy.
🔹 Live Streaming (YouTube, Netflix, Zoom) – Minor packet loss doesn’t ruin the experience.
🔹 DNS (Domain Name System) – Quick lookups of website addresses need speed, not reliability.

Ports & Sockets

What is a Port?

A port is a logical communication endpoint used by networking protocols to identify specific services running on a device. Just like a house has multiple rooms, a computer has multiple ports to handle different types of network traffic.

Each port is assigned a port number, which is a 16-bit integer (ranging from 0 to 65535). The combination of an IP address and a port number allows a computer to distinguish between different network connections.

Types of Port Numbers

Port Range	Name	Description
0 – 1023	Well-Known Ports	Reserved for common services like HTTP (80), HTTPS (443), FTP (21), and SMTP (25).
1024 – 49151	Registered Ports	Used by specific applications like MySQL (3306) and Docker (2375).
49152 – 65535	Dynamic / Private Ports	Assigned dynamically to temporary connections (e.g., video calls, online gaming).

Examples of Common Port Numbers:

Service	Port Number	Protocol
HTTP (Web Browsing)	80	TCP
HTTPS (Secure Web Browsing)	443	TCP
FTP (File Transfer Protocol)	21	TCP
SSH (Secure Shell)	22	TCP
DNS (Domain Name System)	53	UDP
SMTP (Email Sending)	25	TCP

What is a Socket?

A socket is a combination of an IP address and a port number that uniquely identifies a network connection. It acts as an endpoint for sending and receiving data between two devices.

Understanding Socket Address
A socket address is written in the format:
IP Address:Port Number

For example:

192.168.1.10:8080 Here,

192.168.1.10 → Represents the device’s IP address

8080 → Represents the port number where a service (e.g., a web server) is running

Cryptography: Securing Data in the Transport Layer

In computer networks, cryptography plays a crucial role in ensuring secure communication over the internet. It protects sensitive data from unauthorized access, alteration, or interception.

What is Cryptography?

Cryptography is the practice of securing information through encryption and decryption techniques. It ensures confidentiality, integrity, and authenticity in communication.

Key Goals of Cryptography

Confidentiality – Ensures that only the intended recipient can read the data.
Integrity – Ensures that the data is not altered during transmission.
Authentication – Verifies the identity of the sender and receiver.
Non-repudiation – Prevents denial of sending or receiving data.

Cryptography in the Transport Layer

At the transport layer, cryptography is implemented using SSL (Secure Sockets Layer) and TLS (Transport Layer Security) to encrypt and secure data during transmission. These protocols prevent eavesdropping and ensure a secure end-to-end connection between devices.

Conclusion

In this blog, we explored the Transport Layer, understanding its core concepts:

✅ Transport Layer Protocols – TCP (reliable) vs. UDP (fast).

✅ TCP & UDP Headers – Structure and role of each field.

✅ Ports & Sockets – How applications communicate using port numbers.

✅ Cryptography – How encryption secures data transmission.

The Transport Layer is the backbone of reliable data communication, ensuring that messages are delivered correctly and securely.

🙏 Thank You for Reading!

Thank you for reading this blog! I hope it helped you understand the Transport Layer in depth. My final blog on the Application Layer is still pending, so stay tuned! 🚀

📢 Follow me on LinkedIn and X (Twitter) for more updates! 😊

From IP Addressing to Routing: Everything You Need to Know About the Network Layer

Aayush Singh — Mon, 24 Mar 2025 08:00:50 +0000

Welcome back, fellow tech explorers! 🚀 If you've been following my blog series on computer networking, you already know the drill. So far, I’ve covered:

Computer Networking Basics – Where we cracked the networking code.

Data Link Layer (Part 1 & Part 2) – Where we learned how devices whisper
secrets to each other using MAC addresses and frames.

If you haven’t read them yet, go check them out! Trust me, they’ll make this journey much smoother.
Now, let’s talk about the Network Layer – the part of networking that ensures your data finds its way through the chaotic digital highways. Think of it like Google Maps for the internet.

Introduction: The Network Layer

"The Network Layer is the third layer in the OSI (Open Systems Interconnection) model and plays a crucial role in data transmission across networks. It is responsible for routing, forwarding, and addressing data packets to ensure they reach their intended destination." ok done with text book definition now, let's understand it with interesting example:
Imagine ordering a pizza, but the delivery guy has no map. He takes random turns, gets lost, and your pizza never arrives. That's what happens to data packets without proper routing! Luckily, the Network Layer acts like Google Maps, ensuring your data (or pizza) reaches the right destination.

In this blog, we’ll explore how IP addresses, routers, and routing algorithms work together to make internet magic happen. Let’s dive in! 🚦💻

Function of Network layer

Logical Addressing (IP Addressing) – Assigns unique IP addresses to
devices to ensure data reaches the correct destination.
Routing– Determines the best path for data packets to travel across
networks.
Packet Forwarding – Moves packets from one network to another based
on routing decisions.
Fragmentation and Reassembly – Splits large data packets into
smaller ones for transmission and reassembles them at the destination.
Error Handling & Diagnostics – Uses protocols like ICMP to detect
issues like unreachable hosts or network congestion.
Traffic Control & Congestion Avoidance – Manages network congestion
by optimizing data flow and rerouting packets if necessary.

IP Addressing and Subnetting

Before your data finds its way through the network, it needs an address—just like a home address for postal mail. In the networking world, this is done using IP addresses. The Network Layer ensures that every device has a unique identity so that data reaches the correct destination.

IPv4 vs. IPv6: The Addressing Evolution

There are two main types of IP addresses:

IPv4 (Internet Protocol Version 4)

Uses a 32-bit address (4 bytes).
Decimal notation (e.g., 192.168.1.1).
Can support around 4.3 billion unique addresses.
Due to the internet’s rapid growth, IPv4 addresses are running out.

IPv6 (Internet Protocol Version 6)

Uses a 128-bit address (16 bytes).
Hexadecimal Notation (e.g., 2001:0db8:85a3:0000:0000:8a2e:0370:7334)
Can support an almost infinite number of addresses(340 undecillion).
Includes improved security and efficiency features.

Think of IPv4 as old-school phone numbers with limited digits, while IPv6 is like modern international phone numbers with a much larger range.

Classful Addressing: The Traditional IP Addressing Method

Classful addressing was the original method used for IP address allocation, where IP addresses were divided into fixed-size classes.

Each IP address consists of two parts:

Network Part – Identifies the network.(prefix)
Host Part – Identifies individual devices (hosts) within that network.(suffix)

However, classful addressing led to inefficient IP usage, which is why Classless Inter-Domain Routing (CIDR) replaced it. But understanding classful addressing is still important!

IP Address Classes (A to E)

In classfull addressing, IP addresses are divided into five classes (A to E) based on their first few bits and range of values.

1.Class A (Large Networks like ISPs, Government, Large Corporations)

First Bit: Always starts with 0 (binary: 0xxxxxxx).
Range: 1.0.0.0 to 126.255.255.255.
Prefix Length: 8 bits (n = 8) → Net ID: 8 bits, Host ID: 24 bits.
Supports: 16 million hosts per network (2²⁴ - 2 addresses per network).
Example: Google (8.8.8.8), Apple (17.x.x.x) use Class A addresses.

📌 Note: 127.x.x.x is reserved for loopback addresses (used for testing on a local machine).

2.Class B (Medium-Sized Networks like Universities, Large Organizations)

First Two Bits: Always starts with 10 (binary: 10xxxxxx).
Range: 128.0.0.0 to 191.255.255.255.
Prefix Length: 16 bits (n = 16) → Net ID: 16 bits, Host ID: 16 bits.
Supports: 65,536 hosts per network (2¹⁶ - 2 addresses per network).
Example: Many universities and corporations use Class B addresses.

3.Class C (Small Businesses, Local Networks, Home Networks)

First Three Bits: Always starts with 110 (binary: 110xxxxx).
Range: 192.0.0.0 to 223.255.255.255.
Prefix Length: 24 bits (n = 24) → Net ID: 24 bits, Host ID: 8 bits.
Supports: 254 hosts per network (2⁸ - 2 addresses per network).
Example: Home Wi-Fi networks often use private Class C addresses (192.168.x.x).

📌 Note: This class is widely used in private networking (e.g., routers assigning IPs like 192.168.1.1).

4.Class D (Multicast Applications like Streaming, Live Feeds)

First Four Bits: Always starts with 1110 (binary: 1110xxxx).
Range: 224.0.0.0 to 239.255.255.255.
Purpose: Used for multicasting, where one sender transmits to multiple receivers (e.g., video conferencing, IPTV).
No Net ID / Host ID: Instead of assigning hosts, Class D uses group IDs.
Example: Video streaming services and real-time data sharing use multicast addressing.

📌 Note: Class D does not support subnetting since it’s used for group communication.

5.Class E (Experimental & Future Use, Reserved by IETF)

First Four Bits: Always starts with 1111 (binary: 1111xxxx).
Range: 240.0.0.0 to 255.255.255.255.
Purpose: Reserved for future networking research and experiments.
Not Used for Public Internet: No devices or organizations use Class E addresses.
Example: Research institutions and networking experiments may utilize this class.

📌 Note: You cannot assign Class E addresses to hosts or routers in practical networking.

Casting in Networking: How Data is Sent

In networking, casting refers to how data is transmitted from one device to another. There are three main types:

Unicast: Transmitting data from one source host to one destination host.(one to one transmission) (e.g., sending an email to a specific person).

Multicast: Transmitting data from one source host to a particular group of hosts having an interest in receiving the data.(One-to-many communication) (e.g., streaming a live event to multiple users).

Broadcast: Transmitting data from one source host to all other hosts residing in a network either same or other network.(One-to-all communication) (e.g., a DHCP request sent to all devices in a network).

What is Subnetting? Why is it Needed?

Subnetting is the process of dividing a large network into smaller, manageable sub-networks (subnets).

Why is subnetting important?

Helps reduce network congestion by limiting broadcast traffic.
Improves security by isolating different network segments.
Ensures efficient use of IP addresses, preventing wastage.

For example, instead of using a single Class A network with millions of devices, subnetting allows dividing it into smaller networks to improve efficiency.

Subnet Mask: The Key to Subnetting

A Subnet Mask helps identify which part of an IP address belongs to the network and which part belongs to the host.

For example, in 192.168.1.0/24 (Subnet Mask: 255.255.255.0):

192.168.1.0 is the network portion.

The last octet (0-255) represents host addresses.

Common Subnet Masks:

Class A: 255.0.0.0 (/8)

Class B: 255.255.0.0 (/16)

Class C: 255.255.255.0 (/24)

By adjusting the subnet mask, networks can be further divided into smaller subnets, optimizing IP allocation.

Classless Addressing

Classless Addressing is a modern method of IP addressing that removes the limitations of fixed classes (A, B, C) and allows networks to use IP addresses more efficiently. It is implemented through CIDR (Classless Inter-Domain Routing).

Why Was Classless Addressing Adopted?
Classful addressing caused two major problems:

IP Address Wastage:
- Class A networks had 16 million addresses, but even a large organization might use only a few thousand.
- This led to a shortage of available IPv4 addresses.
Rigid Network Sizes:
- Companies needed more flexible subnetting instead of being forced into Class A, B, or C.
- Classless addressing allows custom subnet sizes instead of being stuck with classful limits.

How Classless Addressing Works?
Instead of dividing IPs into strict classes, CIDR allows any number of bits to be allocated for the network and host portions. This helps in efficient IP allocation.

CIDR Notation (Classless Inter-Domain Routing Notation)

CIDR (Classless Inter-Domain Routing) notation is a shorthand representation of IP addresses and their subnet masks. It defines how many bits belong to the network portion of an address.CIDR Notation Format: IP Address / Subnet Bits, The /x (suffix) tells us how many bits are used for the network portion.The remaining bits are used for the host portion.

Example 1: 192.168.1.0/24
/24 means the first 24 bits are for the network.

The last 8 bits are for host addresses.

Subnet Mask: 255.255.255.0

Total Hosts: 2⁸ - 2 = 254 (excluding network and broadcast addresses).

Example 2: 10.0.0.0/16
/16 means the first 16 bits are for the network.

The remaining 16 bits are for host addresses.

Subnet Mask: 255.255.0.0

Total Hosts: 2¹⁶ - 2 = 65,534

How CIDR Improves IP Allocation?
Instead of using fixed Class A, B, or C, CIDR customizes network sizes based on actual needs.
Example: A company may require 5000 IP addresses. In classful addressing, they would need a Class B network (65,536 IPs). With CIDR, they can use a /19 subnet (8192 IPs), avoiding waste.

Supernetting (Merging Multiple Networks into One)

Supernetting is the process of combining multiple smaller networks (subnets) into a larger network to improve routing efficiency. It is the opposite of subnetting.

Used to reduce routing table size by advertising one large block instead of multiple small ones.

IPv4 Header

a payload refers to the actual data being transmitted inside a packet. It is the part of the packet that carries the useful information intended for the receiver, excluding headers, trailers, and metadata.

IPv4 Header Fields

Version – Specifies the IP version being used. For IPv4, this value is always 4.
Header Length (HLEN) – Defines the size of the header. Since IPv4 headers can have optional fields, their size may vary.
Type of Service (ToS) / Services type – Helps prioritize network traffic. For example, video calls may need higher priority than normal browsing.
Total Length – Represents the full size of the packet, including the header and the actual data (payload).
Identification – A unique number assigned to each packet to help reassemble fragmented data. If a large file is broken into smaller packets, this field helps put them back in order.
Flags – Controls fragmentation of packets. It tells whether a packet can be fragmented and if more fragments are coming.
Fragment Offset – If a packet is split into smaller parts, this field helps routers and devices reassemble them in the correct order.
Time to Live (TTL) – Limits how long a packet can travel in a network. Each router decreases its value, and if it reaches zero, the packet is discarded to prevent infinite loops.
Protocol – Indicates which transport layer protocol (like TCP or UDP) is being used to handle the data.
Header Checksum – A mechanism for error detection in the header. If an error is found, the packet is discarded and retransmitted.
Source IP Address – The IP address of the device that sent the packet.
Destination IP Address – The IP address of the intended recipient of the packet.
Options (Optional Field) – Provides extra functionalities like security, timestamp, and routing preferences. It is not commonly used.
Padding (Optional Field) – Fills up extra space in the header to maintain proper alignment for processing efficiency.

Key Limitation of IPv4 Header:

Lacks security features.
Limited address space (only ~4.3 billion addresses).

IPv6 Header Fields

Version – Specifies the IP version being used. For IPv6, this value is always 6.
Traffic Class – Similar to the Type of Service (ToS) field in IPv4, it helps prioritize certain types of network traffic.
Flow Label – Helps maintain smooth and consistent data flow for real-time applications like VoIP and video streaming.
Payload Length – Specifies the size of the actual data (payload) being carried by the packet.
Next Header – Specifies the type of information following the IPv6 header. It helps in identifying whether the next part is TCP, UDP, or additional extension headers.
Hop Limit – Functions like TTL in IPv4, preventing packets from looping indefinitely by decreasing its value at every hop. If it reaches zero, the packet is discarded.
Source Address – The IPv6 address of the sender.
Destination Address – The IPv6 address of the intended recipient.

Key Protocols of the Network Layer: ARP, ICMP, and IGMP

The Network Layer is responsible for moving packets from source to destination. However, just sending packets isn’t enough—devices in a network need to find each other, report errors, and manage group communication. That’s where three important protocols come into play:

ARP (Address Resolution Protocol) – Helps devices find each other in a local network.
ICMP (Internet Control Message Protocol) – Reports errors and network issues.
IGMP (Internet Group Management Protocol) – Manages communication between multiple devices in a group.

Let’s break them down one by one.

Address Resolution Protocol (ARP) – "The Detective of the Network"

Imagine you’re sending a letter to your friend. You know their name, but you don’t know their house number. So, you ask a neighbor, and they tell you the address. That’s exactly what ARP does in a network!

Computers communicate using IP addresses, but actual data travels using MAC addresses (the physical address of a device’s network card). ARP maps IP addresses to MAC addresses so devices can find each other.

🛠 How ARP Works?

If a device wants to send data but only knows the IP address of the receiver, it broadcasts an ARP request asking, "Who has this IP? Tell me your MAC address!"
The device with the matching IP replies with an ARP response containing its MAC address.
The sender now has the MAC address and can send the data.

🔥 Why is ARP Important?

Without ARP, devices in a LAN wouldn’t be able to communicate because they wouldn’t know each other’s MAC addresses.
ARP caches (stores) resolved addresses to speed up future communication.
ARP can be exploited in cyberattacks (ARP Spoofing), where attackers trick a device into sending data to the wrong MAC address.

Internet Control Message Protocol (ICMP) – "The Network's Troubleshooter"

ICMP is like a network doctor—it diagnoses connection problems and reports errors. It doesn’t send actual data but helps troubleshoot packet loss, unreachable networks, and latency issues.

🛠 How ICMP Works?

If a packet fails to reach its destination (e.g., due to an unreachable network), ICMP sends an error message back to the sender.
Network administrators use ping (ICMP Echo Request) to check if a device is online and responding.
Traceroute (ICMP Time Exceeded) helps find the path packets take across the internet.

🔥 Why is ICMP Important?

Helps diagnose connectivity issues (e.g., if a website is down).
Used in ping tests to check if a server or router is active.
Prevents endless loops by setting a Time-to-Live (TTL), so packets don’t travel forever.

Example:
Ping Command (ping google.com) – Sends ICMP Echo Requests to check if Google’s server is online.
Traceroute (tracert google.com) – Shows the path a packet takes to reach Google’s servers.

⚠️ Security Concern:
Attackers can use ICMP in DDoS attacks (e.g., Ping of Death, Smurf Attack) to flood a network with useless traffic.

Internet Group Management Protocol (IGMP) – "The Group Manager"

IGMP helps devices communicate in multicast groups. Instead of sending multiple copies of the same data to different devices, IGMP allows efficient group communication by delivering data to multiple recipients at once.

🛠 How IGMP Works?

A device joins a multicast group (e.g., an online live stream).
The router, using IGMP, registers the device and ensures it receives the multicast data.
When the device leaves the group, IGMP updates the router to stop sending unnecessary traffic.

🔥 Why is IGMP Important?

Reduces network traffic by avoiding duplicate transmissions.
Used in live video streaming, online gaming, and IPTV (Internet TV).
Helps in efficient routing for group-based communication.

Example of IGMP in Action:

Watching a Live Sports Stream: Instead of sending the same video to each viewer individually, the server sends one multicast stream, and IGMP ensures only interested users receive it.

Routing in the Network Layer

Routing is the process of finding the best path for data packets to travel from the sender to the receiver across multiple networks. It ensures that data reaches its correct destination efficiently.

How Does Routing Work?

Every packet has a destination IP address.
Routers analyze the destination address and decide where to forward the packet.
Routers use routing tables and algorithms to determine the best path for packet delivery.

Types of Routing
Static Routing – Routes are manually configured by the network administrator.

Dynamic Routing – Routes are automatically learned and updated using routing protocols.

Default Routing – Used when there is only one exit path for all unknown destinations (common in home networks).

Packet Forwarding and Routing Tables

What is Packet Forwarding?
Once a router decides the best path for a packet, it needs to forward the packet to the next device on the path. This process is called packet forwarding.

What is a Routing Table?
A routing table is a list of rules that helps routers decide where to send packets. It contains:

Destination IP Address – Where the packet needs to go.
Next Hop – The next device/router in the path.
Metric – A value that helps determine the best route (e.g., shortest path, fastest link).

Routing Protocols Used for Packet Forwarding

RIP (Routing Information Protocol) – Uses hop count to find the best path.
OSPF (Open Shortest Path First) – Uses link-state information to calculate the best route.
BGP (Border Gateway Protocol) – Used for routing between different networks on the internet.

Network Address Translation (NAT) & Its Role

Network Address Translation (NAT) is a technique that allows multiple devices in a private network to share a single public IP address to access the internet.

Why is NAT Important?

Solves IPv4 Address Shortage – Since IPv4 addresses are limited, NAT allows multiple devices to use a single IP address.
Adds a Layer of Security – NAT hides internal IP addresses, making it harder for hackers to target devices.
Reduces Costs – ISPs provide fewer public IPs, and companies can still connect multiple devices.

Types of NAT

Static NAT – Maps one private IP to one public IP.
Dynamic NAT – Maps private IPs to a pool of public IPs.
PAT (Port Address Translation) – Multiple private IPs share one public IP using different port numbers (most common type).

Example of NAT in Action
Home Network Example:
Your home router has one public IP address, but multiple devices (laptops, phones, TVs) can browse the internet using that same public IP due to NAT.

Challenges and Security Concerns in the Network Layer

While the network layer ensures smooth communication, it also faces several challenges and security risks:

1. Routing Attacks

Man-in-the-Middle (MITM) Attack – Attackers intercept and manipulate network traffic.
Route Hijacking – Malicious entities advertise incorrect routes, disrupting traffic flow.

2. IP Address Spoofing

Hackers fake an IP address to disguise their identity or impersonate a trusted device.

3. DDoS (Distributed Denial of Service) Attacks

Attackers overload a network with massive traffic, causing services to crash.

4. IPv4 Address Exhaustion

IPv4 addresses are running out, making IPv6 adoption necessary.

5. NAT and Performance Issues

While NAT provides security, it can cause issues with applications that require direct peer-to-peer communication, such as VoIP and online gaming.

Conclusion

The Network Layer is a crucial part of the OSI model that ensures data is properly routed and delivered across different networks. It manages IP addressing, packet forwarding, and routing, making global communication possible. Technologies like IPv4, IPv6, NAT, and routing protocols help in efficient data transmission, while security measures protect networks from attacks.

Thank you for reading! I hope this blog helped you understand the Network Layer better. If you found it useful, feel free to follow me on my social media for more tech content:
🔗 Linkedin
🔗 X (Twitter)

Stay connected and keep learning! 🚀

Error-Free Communication: How the Data Link Layer Ensures Reliable Data Transfer

Aayush Singh — Sun, 23 Feb 2025 17:08:51 +0000

Till now we have studied about MAC addressing, Framing and Random access concepts in Data link layer. In this blog we will Explore more about how the DLL Handle errors in the transmission of data and flow control. so Let's start:

Flow control

Flow control is a technique to prevent the data overflow, the receiver has buffer memory where the incoming data are temporarily stored until processed, and the data processing speed often lags behind the transmission rate.

Flow control can be basically divided in two types:

Stop-and-Wait Flow Control: In this the sender divides data in frames sends one frame(and keep its copy) and wait a particular time(starts a timer) to receive an acknowledgment to send other frame, if the acknowledgment is not received due to any reason in a particular time the sender will resend the frame and again starts the timer. If the acknowledgment is arrived it will discard the frame and sends the other frame. In this method, only one of frames can be in transmission at a time. It leads to inefficiency. see the below diagram to get better understanding.

Lets discuss the diagram:

first frame 0 is send (timer is start), the receiver received it successfully and sends the acknowledgment for transmitting the frame-1.
The sender received the ack 1 successfully and send frame-1 (starts a timer), due to some issue this frame1 is lost, sender will not get any ack after a particular time timer stops ,resend the frame1 and again restarts the timer.
frame1 is successfully arrived and ack 0 is successfully received by sender. Sender sends Frame 0 it is received by receiver but this time the ack 1 get lost. so, the sender does not receive the ack 1 so it resends the frame 0. and this goes on. I hope from the above explanation you got the concept of stop and wait. But before proceeding to another flow control time, let us discuss about some delays to get a better understanding about delays.

You can classify delay in 4 types:
1.Propagration Delay: This is time it takes for a bit to travel from point A to point B in transmission media.(denoted by Tp)

Tp = (Distance) / (propagation speed)

2.Transmission Delay: A sender needs to put the bits in a packet on the line one by one. If the first bit of the packet is put on the line at time t1 and the last bit is put on the line at time t2, transmission delay of the packet is (t2-t1). (denoted by TT)

TT = (packet length) / Transmission rate or Bandwidth

3.Queuing Delay - It is measured as time a packet waits in the input queue and output queue of a router.

queue delay = The time a packet waits in input and output queues in a router

4.Processing Delay - It is a time require for a Destination host to receive a packet from its input port, remove the header,perform an error detection procedure, and deliver the packet to the output port or deliver the packet to the upper-layer protocol(in case of destination host).

Delay = Time require to process a packet in a destination host.

As you know the frames are send one by one in stop-and-wait. It is an inefficient method to transfer frame the more efficient method is Sliding Window flow control. In this multiple frames can be sent before waiting for acknowledgment.

Sliding Window Protocol: Sliding Window allows a sender to transmit several frames consecutively, reducing idle time and improving network efficiency. The "window" refers to the number of frames that can be sent before the sender must pause and wait for acknowledgment. In this example just think window length 15(0-14). If all the 15 frames are send at once. If the sender receives acknowledgment of just say 6, It means all the frames before 6 have definitely been received so it will discard 0-5 and move the window forward to send more.

This protocol operates in two main variants: Go-Back-N ARQ and Selective Repeat ARQ.

1.Go-Back-N Automatic Repeat Request
Go-Back-N Automatic Repeat Request (ARQ) is a sliding window protocol used for reliable data transmission.In this method, the sender can transmit up to N frames (as defined by the window size) before needing an acknowledgment. However, if an error or packet loss occurs, the receiver rejects the erroneous frame and all subsequent frames, forcing the sender to go back and retransmit from the errored frame onward—even if some frames were received correctly.

For example, if a sender transmits frames 1 to 5 and an error occurs in frame 3, the receiver discards frames 3, 4, and 5 and requests retransmission starting from frame 3. This makes Go-Back-N simple to implement but can be inefficient in high-latency networks, as it wastes bandwidth by resending correctly received frames. Despite its inefficiency, it remains widely used in protocols like TCP (with certain modifications) due to its simplicity and robustness.

The send window,an imaginary concept, covers the sequence numbers of frames that can be in transit, having maximum size of 2^m - 1.

Sequence numbers are divided into four regions: the first represents acknowledged frames(no copies kept), the second represents frames sent but with unknown status(outstanding farmes), the third denotes frames ready to be sent pending data packets from the network layer, and the fourth signifies sequence numbers inaccessible until the window slides further.

2.Selective Repeat ARQ : Selective Repeat Automatic Repeat Request (ARQ) is a more efficient sliding window protocol designed to minimize unnecessary retransmissions. Unlike Go-Back-N ARQ, where all frames after an erroneous one are discarded and resent, Selective Repeat only retransmits the corrupted or lost frames, saving bandwidth and improving network efficiency.

In this method, both the sender and receiver maintain separate sliding windows. The receiver stores correctly received frames in a buffer, even if they arrive out of order, and requests retransmission only for the missing or corrupted frames(Negetaive acknowledgment). Once all expected frames are received in order, the data is passed to the upper layer.

For example, if the sender transmits frames 1 to 5, and only frame 3 is lost or corrupted, the receiver will acknowledge frames 1, 2, 4, and 5 and request only frame 3 to be resent. This prevents redundant retransmissions, making Selective Repeat ARQ more bandwidth-efficient than Go-Back-N, especially in networks with high error rates. However, it requires more complex buffering and processing at both sender and receiver, making its implementation more resource-intensive. It is commonly used in high-speed and wireless networks where minimizing retransmissions is crucial.

Error Detection and correction

Understanding Errors in Data Transmission

In any communication system, data transmission errors are inevitable due to various physical and environmental factors. Whether you're sending a text message, streaming a video, or making an online transaction, data must travel through wired or wireless networks, and during this journey, it can get corrupted. Ensuring data accuracy and reliability is crucial, which is why networking protocols implement error detection and correction mechanisms.

What Are Errors in Networking?

An error occurs when the data received at the destination differs from the data sent by the source. These errors are usually caused by: Electromagnetic interference, Noise in transmission mediums, Signal attenuation, Synchronization issues.

Even a single bit error can cause major problems. For example, if a bank transaction of ₹5000 gets altered to ₹9000 due to an error, the consequences can be severe. This is why detecting and correcting errors is a fundamental part of networking.

Types of Errors:

Errors in data transmission are classified into two main types:

Single-Bit Errors A single bit is flipped (0 → 1 or 1 → 0) due to noise or interference. Rare in wired networks but more common in wireless communication.

Example:
Sent: 1011001
Received: 1011101 (4th bit flipped)

Burst Errors Multiple bits are altered in a sequence. More common in wireless and long-distance wired networks.

Example:
Sent: 1101010110
Received: 1100000110 (4-bit burst error)

Since errors cannot always be avoided, networks use error detection and correction techniques to identify and fix corrupted data before it causes failures.

This sets the foundation for understanding how error detection and correction techniques work, ensuring data integrity and reliable communication across networks.

Error Detection and Correction Techniques

Parity Check (Single and Two-Dimensional Parity)

Single Parity Check (Even and Odd Parity): Parity checking is one of the simplest error detection methods, where an extra bit, called the parity bit, is added to a data unit (byte, word, or frame). The purpose of the parity bit is to ensure that the total number of 1s is either even or odd, depending on the chosen scheme.

Even Parity: The number of 1s in the data, including the parity bit, must be even.
Odd Parity: The number of 1s in the data, including the parity bit, must be odd.

Example of Even Parity:
If we want to send the 4-bit data "1010", we add a parity bit to ensure an even number of 1s.

Data Bits	Parity Bit (Even)	Transmitted Bits
1010	0	10100
1101	1	11011

At the receiver end: If an error occurs and the number of 1s becomes odd, it signals that the data is corrupted.

Limitations:

Cannot detect even-numbered bit errors (e.g., two bits flipped won’t change parity).
Does not correct errors, only detects them.
Two-Dimensional Parity Check : To improve error detection, a two-dimensional parity check extends parity checking across multiple data units (rows and columns).

How It Works:

A parity bit is added to each row of data (horizontal parity).
Another parity bit is added for each column (vertical parity).
The receiver checks both row and column parity to identify errors.

2.Checksum

The Checksum method is used in network protocols like TCP/IP to detect errors in transmitted data. Instead of checking individual bits, the checksum verifies an entire block of data by computing a sum of its values.

How It Works:

The sender divides data into equal-sized segments (e.g., 16-bit words).
It calculates the sum of all segments and sends the sum (checksum) along with the data.
The receiver performs the same sum calculation and compares it with the transmitted checksum.
If they match → Data is correct.
If they don’t match → An error is detected.

Example:
Assume we are transmitting two 16-bit data words:

Data 1	Data 2	Checksum (Sum of Data)
10011001 10101010	11001100 11110000	01100110 10100010

If any bit in the data gets corrupted, the receiver's sum will not match the transmitted checksum, signaling an error.

Limitations:

Cannot detect some burst errors, especially if errors cancel each other out.
Does not correct errors, only detects them.

3.Cyclic Redundancy Check (CRC)
Cyclic Redundancy Check (CRC) is a powerful error detection technique used in network protocols like Ethernet and Wi-Fi. It is based on binary division and is more reliable than parity and checksum methods.

How CRC Works:

The sender treats the data as a long binary number.
It divides this number by a predetermined divisor (generator polynomial) using modulo-2 division (binary division without carry).
The remainder of this division is the CRC code, which is appended to the data before transmission.
The receiver performs the same division and checks the remainder:
- If the remainder is zero → No error detected.
- If the remainder is non-zero → Error detected.

Example (Simplified CRC Calculation):

Suppose the data to be sent is 101100 and the divisor (generator) is 1101.
The sender appends zeros (one less than the divisor length) → 101100000.
The sender divides 101100000 ÷ 1101 (using XOR operations).
The remainder (CRC code) is 011, which is appended to the original data.

Data CRC code Transmitted Data

101100 011 101100011
The receiver divides 101100011 ÷ 1101:
- If remainder = 0 → No error.
- If remainder ≠ 0 → Error detected. Advantages of CRC:
Can detect multiple-bit errors (unlike parity and checksum).
Used in high-speed networks like Ethernet.
Efficient for large data blocks.

Data	CRC code	Transmitted Data
101100	011	101100011

Limitations:

Cannot correct errors, only detects them.
Complex compared to parity and checksum methods.

Conclusion

In computer networks, ensuring reliable communication is a combination of error control and flow control. Error control mechanisms like Parity Check, Checksum, and CRC help detect corrupted data, while advanced techniques like ARQ (Automatic Repeat reQuest) ensure lost or erroneous packets are retransmitted. On the other hand, flow control mechanisms like Stop-and-Wait, Sliding Window, and Selective Repeat help regulate data transmission so that a fast sender does not overwhelm a slow receiver. Together, these techniques ensure data integrity and efficient transmission across networks.

Thanks for reading till here! I hope this blog helped you understand error detection, correction, and flow control in the Data Link Layer. In the next blog, we will dive into the Network Layer, where we’ll explore IP addressing, routing, and more. Stay tuned! 🚀 Follow me on Twitter and LinkedIn for more updates.

Bridging the Gap: How the Data Link Layer Keeps Your Network Connected

Aayush Singh — Mon, 10 Feb 2025 18:24:47 +0000

In this blog we are going to deep dive into DataLink layer(DLL). Let's start our discussion with the Textbook definition "The Data Link Layer is the second layer of the OSI model.It is responsible for receiving and getting data bits usually from Physical Layer and then converting these bits into groups, known as data link frames so that it can be transmitted further". In short, its main job is to ensure reliable data transfer between two directly connected nodes.

Key Responsibilities:

Framing: It takes raw bits from the physical layer and organizes them into frames (like envelopes for sending messages).
Error Detection and correction: It checks for errors in transmitted data using methods like parity checks, CRC (Cyclic Redundancy Check), and checksum. For correction, methods like Automatic Repeat Request (ARQ) are used.
Flow Control: Prevents a fast sender from overwhelming a slow receiver, like a traffic signal controlling the flow of cars. It include method like stop-and-wait & Sliding window.
Media Access Control (MAC): MAC Address is a hardware address associated to a network interface card (NIC) or network device. Determines who can send data and when especially in shared networks like Wi-Fi or Ethernet.

Divisions of the Data Link Layer

It has two sublayers:

Logical Link Control (LLC): It handles error detection & flow control. Ensures communication between devices works smoothly.
Media Access Control (MAC): Manages physical addressing (MAC addresses).Controls how devices access and share the network medium (wired or wireless).

Media Access Control

when nodes or stations are connected and use a common link, we need a multiple-access protocol to coordinate access to the link.

In multiple-access protocol we are only going to discuss about Random access protocol, since rest of the protocol is Advance and not much related to CS/IT. Let's start.

Random Access

Random Access Protocols are used in networks where multiple devices share a common communication channel. These protocols allow devices to transmit data whenever they have data to send, but they also have mechanisms to handle collisions (when two devices transmit at the same time).It is called a Random Access Protocol because there is no fixed order or schedule for devices to send data. Instead, devices transmit whenever they have data, leading to random chances of collisions.

Think of it like a group of people talking in a room without a moderator—sometimes, two people talk at the same time, leading to confusion (collision), and they have to pause and retry.

Important Note:
All the protocols in the Random access approach will answer the following questions:

When can the station access the medium?

What can the station do if the medium is busy?

How can the station determine the success or failure of transmission?

What can the station do if there is an access conflict?

1.ALOHA

ALOHA was one of the earliest random access protocols, developed in the 1970s for wireless communication.The main idea of ALOHA is how it handles collisions, which happen when two devices try to send data at the same time, causing interference.
There are two version of ALOHA protocol:

Pure ALOHA

Pure ALOHA refers to the original ALOHA protocol. It is a Random Access Protocol where devices send data whenever they want, without checking if the channel is free. If two devices transmit at the same time, a collision occurs, and they need to retransmit after a random time.

Since multiple devices can transmit at the same time, collisions are common.If the receiver does not send the acknowledgment, the sender will assume that it has not been received and sender resends the message.

Since collisions are frequent, much of the network capacity is wasted.maximum efficiency of Pure ALOHA is only 18.4%, meaning most transmissions fail.Pure ALOHA is mainly used in wireless communication (satellites, RFID systems) where devices cannot easily detect other transmissions.

With this diagram you can clearly see that last bit of frame A is colliding with first bit of frame B. vulnerable time in which there is a possibility of collision, we can see that the time during which the collision may occur in pure ALOHA. Vulnerable time = 2*Transmission delay (we will discuss Transmission delay later).

2.Slotted ALOHA
Slotted ALOHA is an improved version of Pure ALOHA that reduces collisions by dividing time into fixed slots. Devices can only send data at the beginning of a time slot, which synchronizes transmissions and improves efficiency with max efficiency of 36.8%.

The channel is divided into equal-sized time slots, and devices can only send data at the start of a slot.
This ensures that collisions can only happen if two devices pick the same slot, unlike Pure ALOHA where collisions happen anytime.
If a collision happens, devices wait for a random number of time slots before trying again.This helps reduce repeated collisions in the next slot.
Slotted ALOHA is used in wireless systems where devices can be synchronized, like satellite uplinks and RFID (contactless card systems).

2.Carrier Sense Multiple Access (CSMA)

CSMA reduces collisions by first listening to the channel before transmitting which means In this protocol, each device first sense the channel before sending the data. If the channel is busy, the device waits until it is free. This helps reduce collisions. There are two ways to check if the channel is busy or idle:

Persistent CSMA: Keeps checking and sends immediately if the channel is free. (Higher chance of collision).

Non-Persistent CSMA: Waits a random time before checking again. (Reduces collision chances).

3.CSMA/CD (Carrier Sense Multiple Access with Collision Detection)

CSMA/CD is used in wired networks (Ethernet) to detect and handle collisions when multiple devices transmit at the same time. If a collision occurs, devices stop transmission, send a jam signal, and retry after a random delay to avoid repeated collisions.

How CSMA/CD Works?

Carrier Sense (Listen Before Sending):
- The device listens to the channel before sending data.
- If the channel is free, it sends the data.
- If the channel is busy, it waits for a random time before trying again.
Collision Detection (Detecting a Crash):
- If two devices send data at the same time, a collision happens, and data gets corrupted.
- Devices can detect this because they hear a jumbled signal (like overlapping voices in a room).
Jam Signal (Alert Everyone):
- When a collision is detected, a "jam signal" is sent to notify all devices.
Random Backoff (Wait and Retry):
- The devices that collided wait for a random time before retransmitting
- This helps reduce repeated collisions.

Imagine a two-way road where cars can only pass if the road is clear:

A driver (device) checks if the road is empty (carrier sensing).
If clear, the driver moves.
If two cars move at the same time (collision), they both stop (detect collision).
They wait for a random time before trying again to avoid another crash.

4.CSMA/CA (Carrier Sense Multiple Access with Collision Avoidance)

CSMA/CA is used in wireless networks (Wi-Fi) to prevent collisions before they happen. Devices first send an RTS (Request to Send) signal, wait for a CTS (Clear to Send) response, and then transmit data to ensure smooth communication.

Why CSMA/CA is Needed for Wireless?

In Wi-Fi, devices cannot "hear" each other's transmissions properly (hidden node problem).
Unlike Ethernet, wireless signals can’t detect collisions, so CSMA/CA prevents collisions instead of detecting them.

How CSMA/CA Works?

Carrier Sense (Listen Before Sending):
- The device checks if the channel is idle.
- If busy, it waits before trying again.
Request to Send (RTS) & Clear to Send (CTS):
- Instead of just sending data, the device first sends an RTS (Request to Send) signal to the access point (Wi-Fi router).
- If the channel is free, the router replies with a CTS (Clear to Send) signal.
Data Transmission (Safe to Send) :
- After receiving CTS, the device transmits data.
- Other devices stay silent to avoid interference.
Acknowledgment (ACK):
- The receiver sends an ACK (Acknowledgment) message confirming successful reception.
- If no ACK is received, the sender assumes a collision happened and retries after a random time.

Imagine a classroom where students ask for permission to speak:

A student (device) raises their hand (RTS - Request to Speak).
The teacher (Wi-Fi router) grants permission (CTS - Clear to Speak).
The student speaks (data transmission).
The teacher nods (ACK) to confirm the message was heard.

MAC Address

A MAC address is a 48-bit (6-byte) unique hardware address assigned to a network interface card (NIC) by the manufacturer. It is used to identify devices in a Local Area Network (LAN).

Format :
A MAC address is usually written in hexadecimal format, separated by colons or hyphens.
- Example: 00:A0:C9:14:C8:29 or 00-A0-C9-14-C8-29

Structure (6 Bytes = 48 Bits)

First 3 Bytes (24 bits)	Last 3 Bytes (24 bits)
Organizationally Unique Identifier(OUI) - Assigned to manufacturer	Device Identifier(NIC Specific) - Unique to each device
Example: 00:A0:C9 → Manufacturer	Example: 14:C8:29 → Unique Device ID

Here are some OUI of well-known manufacturers:

CC:46:D6 - Cisco
3C:5A:B4 - Google, Inc.
3C:D9:2B - Hewlett Packard
00:9A:CD - HUAWEI TECHNOLOGIES CO.,LTD

Why is a MAC Address Needed?

Uniquely identifies devices in a network (like a fingerprint for your computer).
Used in the Data Link Layer for local communication within a LAN.
Helps switches forward data to the correct device in a network.

Types of MAC Addresses
MAC addresses can be categorized based on their purpose:

Type	Description
Unicast MAC Address	Used to send data to a single specific device in a network.
Multicast MAC Address	Used to send data to a group of devices (e.g., video streaming).
Broadcast MAC Address	Used to send data to all devices in a network (FF:FF:FF:FF:FF:FF).

Example:

If a switch wants to send data to one computer, it uses a unicast MAC address.
If a router wants to send data to all devices in a network, it uses the broadcast MAC address (FF:FF:FF:FF:FF:FF).

How MAC Addresses Work in a Network?
When a device wants to communicate, it follows these steps:

Step 1: The sender checks the MAC address of the destination using the ARP (Address Resolution Protocol).
Step 2: The sender adds the MAC address to the data frame and sends it.
Step 3: A network switch reads the MAC address and forwards the data to the correct device.

Example:
If your laptop sends a request to a printer in a LAN, the request contains the printer's MAC address, so the switch knows where to send the data.

MAC Address vs. IP Address – What's the Difference?

Feature	MAC Address	IP Address
Definition	Unique hardware address of a device	Logical address assigned to a device
Layer	Data Link Layer (Layer 2)	Network Layer (Layer 3)
Type	Physical (cannot change)	Logical (can change)
Used By	Switches	Routers
Example	00:A0:C9:14:C8:29	192.168.1.1

Analogy:

A MAC address is like a house address (permanent).
An IP address is like a temporary hotel room number (can change).

To find your MAC address just open your command prompt type ipconfig /all and press Enter. Look for "Physical Address" under your network adapter.

Framing in Data Link Layer

What is Framing?
Framing is the process of dividing a stream of data into small manageable units called frames for transmission over a network. Each frame contains both data and necessary control information (such as addresses and error detection codes) to ensure reliable communication.

Why is Framing Needed?

The physical layer (Layer 1) only transmits raw bits (0s and 1s) without meaning.
The data link layer (Layer 2) groups these bits into meaningful frames for error detection, synchronization, and addressing.
It allows the receiver to correctly identify the start and end of each data unit.

Example Analogy:

Imagine a long letter written without spaces or punctuation—it would be hard to read!
Framing adds spaces, punctuation, and envelopes so that the receiver can properly understand each message.

Components of a Frame
Each frame consists of three main parts:

Part	Purpose
Header	Contains control information like source & destination MAC addresses
Data	The actual payload (message) being transmitted
Trailer	Contains error detection codes to ensure correct data transmission

Error Detection in Framing
The trailer of a frame includes an error detection code to ensure data integrity.

Common Error Detection Techniques:

Parity Bit: Adds an extra bit to make the number of 1s either even or odd.
Checksum: A sum of all data bits is added and verified at the receiver’s end.
Cyclic Redundancy Check (CRC): A mathematical formula generates a check code, which is compared on both ends.

Conclusion

In this blog, we explored the Data Link Layer, the backbone of network communication. We delved into key concepts like framing, MAC addressing, and random access protocols such as ALOHA, CSMA, CSMA/CA, and CSMA/CD. These mechanisms ensure efficient data transmission and collision avoidance, keeping networks connected and functional.

In the next blog, we’ll dive into the Logical Link Control (LLC) sublayer, covering error detection, correction, and flow control. Let’s keep the conversation going! Connect with me on: Linkedin & X(formally twitter).

Computer Networking 101: The Digital Superhighway Explained

Aayush Singh — Sun, 02 Feb 2025 04:26:48 +0000

Imagine the internet as a massive, interconnected highway system. Just like roads connect cities, towns, and homes, computer networks connect devices, allowing them to communicate and share information. This is the essence of computer networking—a digital superhighway that enables seamless communication across the globe. In this blog, we’ll break down the basics of computer networking, its goals, structure, and the technologies that make it all possible. Buckle up, and let’s hit the road!

What is Computer Network?

Computer networking is a telecommunication network that allows autonomous digital devices(nodes), to exchange data between each other using either wired or wireless connections, to share resources interconnected by a single technology, e.g. the Internet. Think of it as a postal system: devices (like your laptop or smartphone) are like houses, and the network is the postal service that delivers messages (data) between them.

Goals and Applications of Computer Networking

Why do we need computer networks? Here are the primary goals and applications:

1.Resource Sharing: Networks allow devices to share resources like printers, files, and internet connections.

2.Communication: Networks enable real-time communication through emails, video calls, and messaging apps.

3.Data Storage and Access: Networks provide access to centralized data storage systems like cloud services.

Example: Google Drive lets you store and access files from anywhere.

4.Scalability and Flexibility: Networks allow businesses to grow and adapt by adding new devices and users easily.

Data communication

Data communication system has 5 components:
1.Message -> Information(data) to be communicated e.g. text,audio.
2.Sender -> device which sends message.
3.Receiver -> device which receives message.
4.Transmission medium -> is the physical path by which message travel from sender to receiver.
5.Protocol -> set of rules and guidelines for communicating data between devices.

Transmission Mode

When data travels across a network, it doesn’t just move in one fixed way. The transmission mode determines the direction and flow of data between devices. Think of it as the rules of the road for data traffic—whether it’s a one-way street, a two-way street, or a multi-lane highway. Let’s explore the three main types of transmission modes:
1.Simplex Mode : In simplex mode, data flows in only one direction—like a one-way street. One device sends data, and the other can only receive it. There’s no way for the receiver to send data back.

for example: A radio broadcast. The radio station sends out signals, and your radio can only receive them. You can’t send a message back to the station.

2.Half-Duplex Mode : In half-duplex mode, data can flow in both directions, but not at the same time. It’s like a narrow bridge where cars must take turns to cross.

for example: Walkie-talkies. You can talk or listen, but you can’t do both at the same time. You say “Over” to signal the other person to respond.

3.Full-Duplex Mode : In full-duplex mode, data can flow in both directions simultaneously. It’s like a multi-lane highway where cars can travel in both directions at the same time without interfering with each other.

Example: Modern Ethernet networks, Wi-Fi, and cellular networks.

Network criteria

A network must be able to meet a certain number of criteria. The most important of these are:
1.Delivery & Accuracy - Must deliver the data to correct destination without any error.

2.Performance - Can be measured in many ways including transit time,response time,number of users,types of transmission medium,capability of connecting hardware's and efficiency of software.

3.Reliability - Is a measure of frequency of failure and the time taken to resolve from the failure.

4.Security

Types of connection

1.Point-to-point - A point-to-point connection provides a dedicated link between two devices.
2.Multipoint - A multipoint connection is one in which more than two specific devices share a single link.

Network Topology

Mesh Topology: Every device is connected to every other device in the network. It’s like a spider web, where each strand is a direct connection.

Example: Military networks or critical infrastructure systems where reliability is paramount.
Star Topology: All devices connect to a central hub.

Example: Home Wi-Fi networks.
Bus Topology: Devices are connected in a single line.

Example: Older Ethernet networks.
Ring Topology: Devices are connected in a circular loop.

Example: Token Ring networks.
Hybrid Topology: A hybrid topology combines two or more different topologies to create a customized network.

Example: A large office might use a star topology for individual departments and connect them using a bus topology.

Network Structure and Architecture

Networks are built using a combination of hardware (like routers and cables) and software (like protocols). The structure of a network can vary depending on its size and purpose:

Local Area Network (LAN): A small network covering a single building or home.

Example: Your home Wi-Fi network.
Wide Area Network (WAN): A large network that spans cities, countries, or even continents.

Example: The internet.
Metropolitan Area Network (MAN): A network that covers a city or campus.

Example: A university’s network connecting multiple buildings.

The OSI Reference Model: The 7-Layer Highway

The OSI (Open Systems Interconnection) model is a framework that explains how data travels across a network. It’s divided into seven layers, each with a specific role. Think of it as a multi-layered highway system:

Physical Layer (Layer 1): The actual road—cables, switches, and signals.

Example: Ethernet cables or Wi-Fi signals.
Data Link Layer (Layer 2): Ensures data is transferred reliably between devices on the same network.

Example: MAC addresses used in Ethernet.
Network Layer (Layer 3): Routes data between different networks.

Example: IP addresses and routers.
Transport Layer (Layer 4): Ensures data arrives error-free and in the correct order.

Example: TCP (Transmission Control Protocol).
Session Layer (Layer 5): Manages connections between devices.

Example: Establishing a Zoom call.
Presentation Layer (Layer 6): Translates data into a readable format.

Example: Encryption or file compression.
Application Layer (Layer 7): The interface between users and the network.

Example: Web browsers (Chrome, Firefox) or email clients (Outlook, Gmail).

Physical Layer and Transmission Media

The physical layer deals with the actual transmission of data. Common transmission media include:

Wired Media: Ethernet cables(Coaxial Cables,Twisted Pair Cables,Fiber optic Cables).
Wireless Media: Wi-Fi, Bluetooth, cellular networks.

Switching Methods

Switching determines how data is forwarded across the network:

Circuit Switching: Dedicated path for the entire communication.

Example: Traditional phone calls.
Packet Switching: Data is broken into packets and sent independently.

Example: Internet data transfer.

Conclusion

Computer networking is the backbone of our digital world, enabling communication, resource sharing, and access to information. By understanding the basics—like the OSI model, network topologies, and transmission media—you can appreciate the complexity and beauty of this digital superhighway. Whether you’re sending an email, streaming a movie, or browsing the web, you’re riding on this incredible network. So next time you connect to Wi-Fi, remember: you’re not just online—you’re on the digital superhighway!

But this is just the beginning! In the next blog of this series, we’ll dive deeper into the Data Link Layer.Make sure to follow me on LinkedInand X (formerly Twitter) to stay updated with the latest posts, tips, and insights

Leveling Up in Git and GitHub: A Guide to Remotes, Pull Requests, and Beyond

Aayush Singh — Tue, 07 Jan 2025 17:26:37 +0000

This blog continues from my previous one. It is helpful to have a basic understanding of Git before proceeding.

Working with Remote Repositories(GITHUB)

Remote repositories are hosted versions of your local Git repository that allow multiple developers to collaborate on a project. GitHub is a popular platform for hosting such repositories. Let’s break down this topic with detailed explanations and examples.

Setting Up a Remote Repository

1.Create a Repository on GitHub

Select "New Repository."
Name your repository (e.g., my-project) and choose whether it’s public or private.
Click Create Repository.

Optional step:
git branch -M main : This command will rename your local branch from master to main, which is now more preferred..

2.Link Your Local Repository to the Remote Repository
Command:

git remote add origin <repository-URL>

Replace <repository-URL> with the HTTPS or SSH link from GitHub.

3.Verify the Remote Link
Command:

git remote -v

output:

origin  https://github.com/username/my-project.git (fetch)
origin  https://github.com/username/my-project.git (push)

Pushing Changes to the Remote Repository

Pushing uploads your local commits to the remote repository.
Command:

git push origin <branch-name>

If it’s your first time pushing:

git push -u origin <branch-name>

This command sets the default remote branch for future pushes. By including this, the specified branch becomes the default, allowing you to push and pull from your remote repository simply using git push and git pull. Without this setting, you would need to specify the branch name every time you push or pull.

Cloning a Remote Repository

Cloning creates a copy of an existing repository on your local machine.
Command:

git clone <repository-URL>

you can get <repository-URL> by going on your repo and clicking Code button.

Fetching remote repo

git fetch downloads the latest commits, branches, and tags from a remote repository but does not merge them into your local branch. It’s like “checking what’s new” without changing your work.

git fetch

# Fetching changes from origin main into your local main
git fetch origin main

Merge remote repo

git merge integrates changes from one branch into another. You use it after fetching to bring remote updates into your local branch.

#1. Merge remote main
git fetch origin main
git merge origin/main

# 2. Merge local main branch into feature
git checkout feature
git merge main

Pulling remote repo

git pull is a shortcut for fetch + merge. It fetches the latest changes from the remote and then automatically merges them into your current branch.

git pull

# Pull changes from origin main directly into your local main
git pull origin main

This ensures your local branch is up-to-date with the remote branch.

Resolving Merge Conflicts

A merge conflict occurs when two branches (or local and remote repositories) modify the same part of a file.

Steps to Resolve:

Git identifies the conflicting file(s).

Open the file(s) and look for conflict markers like:

<<<<<<< HEAD
Your changes here
=======
Changes from the remote branch
>>>>>>> branch-name

Edit the file to keep the desired changes.
Stage the resolved file: git add <file>
Commit the changes: git commit

Collaboration in GitHub

GitHub is a powerful platform for team collaboration. Here's how it helps developers work together effectively:

1 Forking a Repository

Forking creates a personal copy of someone else's repository on your GitHub account.

STEPS:

Click the Fork button on the repository's GitHub page.
Your forked copy will appear in your GitHub account.

2 Pull Requests

A pull request (PR) is a request to merge your changes (usually in a feature branch of your forked repository) into the original repository.Lets others review, discuss, and merge your changes into the main project.

STEPS:

Push your changes to your forked repository.
Click New Pull Request on the original repository's page.
Compare your changes and describe them before submitting.

3 Reviewing Code

Reviewing code involves examining PRs for correctness, style, and quality before merging.Ensures that the codebase remains high quality and free of errors.
Key Actions:

Add comments.
Approve the PR.
Request changes if needed.

Step-by-Step Workflow to contribute to an original project

0 Create a issue or find the issue to solve by going in Issue tab

1 Fork the Original Repository, by clicking fork button

2 Clone Your Forked Repository
Clone your fork to your local machine:

git clone https://github.com/your-username/forked-repo.git

Navigate into the project directory:

cd forked-repo

3 Set the Original Repository as an Upstream
This ensures you can sync your fork with the original repository.
Add the original repository as an upstream remote:

git remote add upstream https://github.com/original-owner/original-repo.git

Check the remotes:

git remote -v

Output:

origin   https://github.com/your-username/forked-repo.git (fetch)
upstream https://github.com/original-owner/original-repo.git (fetch)

4 Create a Feature Branch
Before making changes, create a new branch for every issue. Branches should be named like feat/abc, fix/abc . Always remember create any branch from main branch only:

git checkout -b feature-branch

Make your changes, test them, and commit them:

git add .
git commit -m "Add feature X"

5 Sync with the Original Repository (if needed)
Before creating a pull request (PR), ensure your fork is up-to-date with the original repository.

Pull changes from the original repository set as upstream:

cd main
git pull upstream main

merge local up-to-date repo to update remote(origin) repo:

git push origin main

Now merge this local main branch with feature-branch:

git checkout feature-branch
git merge main

Now your feature branch is up-to-date. if there any merge conflict resolve it and commit them.

6 Push Changes to Your Forked Repository
Push the feature branch to your forked repository:

git push origin feature-branch

7 Create a Pull Request (PR)
On GitHub:

Go to your forked repository.
Switch to the feature-branch.
Click Compare & pull request.
Write a descriptive title and summary for your changes.Remeber to add fixes #issueid in your PR description
Submit the PR to the original repository's main branch.
Stay clam, and do all the necessary changes told to you by maintainers and push them too.
After your branch is successfully merged, you can delete that feature-branch.

Managing Issues and Projects

GitHub provides tools for tracking bugs, features, and tasks.
1 Issues
Issues are GitHub’s way of tracking bugs, feature requests, or tasks.Centralized discussion for solving problems.Think of issues as sticky notes on a whiteboard, each representing something that needs attention.
Steps to Create an Issue:

Go to the Issues tab in the repository.
Click New Issue.
Describe the problem or request.

2 Labels
Labels categorize issues (e.g., "bug," "enhancement").Labels are like tags you put on your sticky notes to organize them.

3 Milestones
Milestones group related issues to track progress toward a specific goal.Like grouping sticky notes for a project deadline.

4 GitHub Projects
A project board organizes issues and pull requests into a visual workflow.Like a Kanban board with columns for "To Do," "In Progress," and "Done."

Doing this much is enough for beginner for now to get started. now I will discuss about some advance concept if you came till here, I will encourage you to read and try to understand basics of this advance concept

Advanced Git Concepts

1 Rebasing
Rebasing rewrites commit history to create a linear sequence of commits.Imagine organizing your shuffled photo album into chronological order.
command:

git rebase <branch-name>

2 Cherry-Picking
Apply a specific commit from one branch to another.Like copying a single page from one book into another.
command:

git cherry-pick <commit-hash>

3 Stashing
Temporarily saves uncommitted changes to a stack.Like putting your work on hold and tucking it into a drawer.git stash is like moving changes to backstage and calling it to the untracked area with git stash pop or deleting backstage data with git stash clear.

git stash
git stash apply

Working with CI/CD Pipelines

What is CI/CD?
Continuous Integration (CI) ensures code changes are tested automatically, and Continuous Deployment (CD) automates code deployment. Like a factory assembly line that builds, tests, and ships products automatically.

GitHub Actions
GitHub’s built-in CI/CD tool for automating workflows.Like a robot that handles repetitive tasks for you.

GitHub Features

1 GitHub Pages
Host a static website directly from a GitHub repository. Use it for a portfolio or project demo.
Steps:

Go to the repository settings.
Enable GitHub Pages under the Pages section.

2 Insights and Analytics
View contributor stats, commit history, and activity graphs.Helps understand how a project evolves and who contributes the most.

3 GitHub Discussions
A forum-like feature for open-ended discussions.For brainstorming or getting help without creating issues.

4 Security Features

Dependabot Alerts: Scans for vulnerabilities in dependencies.
Code Scanning: Detects security issues in your code.

Conclusion

Thank you for reading this blog till the end! I hope it gave you a clear understanding of Git and GitHub, from the basics to essential commands, collaboration, and exploring GitHub’s powerful features. With these skills, you’re now well-equipped to start contributing to projects, managing your own repositories, and collaborating effectively with others. 🚀

What can you do now?

Begin experimenting with Git commands and workflows in your own projects.
Contribute to an open-source project to solidify your learning.
Explore GitHub’s advanced features like GitHub Actions or Pages to level up your skills. If you found this blog helpful, let’s connect! You can follow me on X (formally twitter) and LinkedIn to stay updated with my journey and future blogs.

Stay tuned for my next blog, where I’ll dive deeper into diffrent topics. Until then, happy coding! 😊

Getting Started with Git and GitHub: A Beginner's Guide

Aayush Singh — Sat, 04 Jan 2025 10:48:52 +0000

Basics of Git

Git is a tool that helps developers track changes in their code. It’s like a time machine for your project, allowing you to see what changed, when, and by whom.

what is Git and why it is used?

Git is a version control system that helps you manage changes to files in your project over time. Imagine writing a book, Git is like a notebook where you record every change you make to your draft. If you mess up, you can look back at your notes and restore an earlier version of the book.
It is used to:

save versions of your work
collaborate with others
keep track of changes without losing anything

Now after you have understood what Git is Now lets install Git.

Installing and configuring Git

Install Git on your system by downloading it from: git-scm.com. follow the instructions provided on the official website to: Install Git
After Installing open Git Bash. as shown in below image

Then configure your name using the command:

git config --global user.name "Your Name"

Finally configure your email with:

git config --global user.email "your-email@example.com"

Now you have saved you name and email.lets verify everything using below command:

git config --global --list

Before starting with git commands. let's first understand some terminology related to git

Git Terminology

Repository (Repo) : A repository is where Git stores all your project files and their version history.Think of a repository as a folder where you keep your project. Git keeps a hidden "diary" in that folder, recording everything you do.
Working Directory : The working directory is the folder where you’re actively working on your files.It’s like your desk where you spread out your papers to edit.
Staging Area : The staging area is where you prepare files before saving them in Git’s history. Imagine a box(staging area) where you gather paper(files) to click a photo (commit).
commit : A commit is a snapshot of your project at a specific point in time.Imagine taking a photo of your desk. A commit freezes the current state of your work so you can always look back at it later.
Branch : A branch is a separate line of development in your project.It’s like working on a copy of your book while keeping the original safe. Once you’re done, you can merge the changes back into the main book.
Merge : Merging combines changes from one branch into another.If two people write different chapters of a book, merging is putting those chapters together into one final draft.
HEAD : HEAD is the pointer to your current commit or branch.HEAD is like a bookmark showing where you are in your project history.

Now you are done with Git basics let's dive into Git commands.

Essential Git Commands

These are the basic command that you will encounter daily. so Let's start:

git init : This initializes a new Git repository in your project folder, allowing Git to track changes.

git init

This creates a hidden .git folder in your project directory, setting up Git for version control.

git add : This command moves changes (modified or new files) from the working directory to the staging area.

git add file1.txt # Add file1.txt to staging area
git add .  # Adds all changes in the current folder

This prepares files for committing.

git commit : This saves the changes in the staging area as a snapshot in Git's history. Each commit has a unique ID and message to describe the changes.It’s like taking a photograph of your project at a specific moment.

git commit -m "Added a new feature to the homepage"

git status : This command shows the current state of the working directory and staging area. It tells you what changes have been staged, what changes are not staged, and which files are untracked. Example:

git status

output:

On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        file1.txt
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   file2.txt

git log : This command displays the history of commits in your repository, showing the commit hash, author, date, and message.

git log

# or

git log --oneline # for single line response

Git Diff : git diff is used to see the differences in your code. It helps you compare changes between your working directory, staging area, commits, or even branches. This is especially useful before committing or merging code.

# Show changes in working directory that are not staged
git diff

# Show changes that have been staged (ready for commit)
git diff --staged

# Compare two commits using their hash IDs
git diff <hashid1> <hashid2>
# You can get commit hash IDs using: git log --oneline

# Compare differences between two branches
git diff branchone..branchtwo

Use git diff to review changes and ensure you’re committing exactly what you want.

Working with Branches

A branch in Git is like a separate line of development. It allows you to work on new features, fix bugs, or experiment without affecting the main code.

Create a Branch:

git branch feature-branch

Creates a new branch called feature-branch.

Switch to a Branch:

git checkout feature-branch

Switches to the branch feature-branch.

OR
(modern way):
git switch feature-branch

Create and Switch to a Branch (Shortcut):

git checkout -b feature-branch

List All Branches:

git branch

Shows all branches in the repository. The current branch is marked with *.

Merge a Branch:

git merge feature-branch

Combines changes from feature-branch into the current branch.

Delete a Branch:

git branch -d feature-branch

Deletes feature-branch after it’s merged.

Imagine you’re writing a book. The main branch (main) is your final version. When you want to write a new chapter, you make a photocopy (a branch). You work on this copy separately. Once done, you add the new chapter to the main book (merge the branch).

Remember: Depending on your PC environment, your local repository may have a default branch named either main or master. In this guide, we'll use main as the default branch name, aligning with GitHub's recent change from master to main.

Understanding Git Stashing

When working with Git, there are times when you’re in the middle of changes but need to switch branches, pull new code, or experiment without committing incomplete work. This is where Git Stash comes in handy.

Stashing lets you temporarily "shelve" (or stash) changes in your working directory so you can work on something else, and then come back later to reapply them.

Common Git Stash Commands

1. git stash
This command saves your uncommitted changes (both staged and unstaged) into a new stash entry and reverts your working directory to match the last commit.

git stash

Think of it as "hiding" your work temporarily.

2. git stash pop

This command reapplies the most recently stashed changes and then removes them from the stash list.

git stash pop

Use this when you want to get your changes back and don’t need to keep the stash for later.

3. git stash list

Displays all stashes you have saved. Each stash will be shown with an index like stash@{0}, stash@{1}, etc.

git stash list

Helpful when you have multiple stashes saved.

4. git stash apply

This reapplies the most recent stash (or a specific one if you provide an identifier) without deleting it from the stash list.

# Apply the most recent stash
git stash apply

# Apply a specific stash by index
git stash apply stash@{2}

# Apply a stash by commit hash ID
git stash apply <hashid>

Use this if you want to reapply changes but still keep a copy in the stash.

5. git stash show

Shows a summary of the changes in the most recent stash. Use -p (patch) to see the full diff.

git stash show
git stash show -p

6. git stash drop

Deletes a specific stash entry (default is the latest one).

git stash drop stash@{0}

Useful if you don’t need a particular stash anymore.

7. git stash clear

Removes all stashes from the list.

git stash clear

Be careful — once cleared, you cannot recover them.

Example Workflow

You’re working on a feature but need to quickly fix a bug on another branch:

  git stash
  git checkout main

After fixing the bug, you come back and reapply your feature work:

  git checkout feature-branch
  git stash pop

Undoing Changes in Git

Mistakes happen, and Git makes it easy to undo changes at different stages. Let’s explore common scenarios with examples and outputs.

Undo Changes in the Working Directory (git checkout or git restore)

If you’ve made changes to a file but haven’t staged it yet, you can discard those changes.
command:

git restore <file>

Example:
Suppose you edited index.html but don’t want the changes.

git restore index.html

Output:
The file index.html is restored to the last committed version. Changes are discarded.

Unstage Changes (git restore --staged)

If you’ve staged a file using git add but want to remove it from the staging area without deleting changes:

command:

git restore --staged <file>

Example:
You staged style.css but realize it’s not ready to commit.

git restore --staged style.css

Output:

The file is moved back to the working directory, and git status will now show it as modified but not staged.

Note: If this command does not work in your device use git rm --cached <file>

Undo a Commit (git reset)

a. Undo the Last Commit (Keep Changes in Working Directory):

Command:

You committed too early and want to redo it.

git reset --soft HEAD~1

Output:

The last commit is undone, but changes remain in the staging area.

b. Undo the Last Commit (Unstage and Keep Changes):

Command:

git reset --mixed HEAD~1

Output:
The last commit is undone, changes are unstaged, and files are moved to the working directory.

c. Undo the Last Commit (Delete Changes):

Command:

git reset --hard HEAD~1

Example:
You committed unwanted changes and want to completely discard them.

git reset --hard HEAD~1

Output:
The last commit is undone, and changes are permanently deleted.

Undo Changes in a Specific Commit (git revert)

Instead of deleting a commit, this creates a new commit that undoes the changes.
Command:

git revert <commit-hash>

Example:
To undo changes in commit abc123:

git revert abc123

Discard Untracked Files (git clean)

Untracked file are the files you haven’t added to the staging area using git add. .
If you’ve added new files but don’t want to keep them:
command:

git clean -f

Example:
You created a file temp.txt but don’t need it.

git clean -f

Output:
The untracked file temp.txt is deleted.
Note: git clean -f command will delete all untracked files in your working directory. Here, -f flag is required to confirm you want to delete the files(Force Deletion).

Important Tip:
Dry Run Before Cleaning: To see which files will be deleted without actually deleting them, use git clean -n.
git clean -n

Summary Table:

Action	Command
Undo changes in a file	git restore
Unstage changes	git restore --staged
Undo last commit (soft)	git reset --soft HEAD~1
Undo last commit (hard)	git reset --hard HEAD~1
Undo a specific commit	git revert
Discard untracked files	git clean -f

Git is an essential tool for managing code efficiently, and in this blog, we’ve covered the foundational concepts and commands you need to get started. From initializing repositories to branching and undoing changes, these skills form the backbone of version control and will help you work confidently in your projects.

Understanding these basics ensures you can track your progress, experiment without fear, and fix mistakes when things don’t go as planned. The remaining topics, such as working with remote repositories (GitHub), collaboration workflows, and advanced features, will be covered in my next blog. Stay tuned for more!

If you found this blog helpful or have any suggestions, feel free to reach out to me. Let’s connect TWITTER & Linkedin. Your feedback and support mean a lot to me as I continue sharing my journey in the tech world. 😊

Mastering Classes and Objects: Step-by-Step for Beginners

Aayush Singh — Sun, 29 Dec 2024 02:52:58 +0000

Introduction to Classes and Objects

In programming, a class is like a blueprint, and an object is like a house built from that blueprint. Think of a class as a plan that defines the structure and behavior of an object. An object, on the other hand, is a specific instance of that class that exists in memory. By using classes and objects, we can organize and reuse code effectively.

For example:

class Car {
    String color;
    String model;
    void start() {
        System.out.println("Car is starting");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // Object created
        myCar.color = "Red";
        myCar.start();
    }
}

Here, the Car _class is a blueprint, and _myCar is an object created from that blueprint.

Components of a Class

A class is made up of several components. Let’s break them down:

Class Name

The class name is used to identify the class. It should follow naming
conventions:

Start with an uppercase letter.
Use camel case (e.g., Car, StudentDetails).
Avoid Acronyms and Abbriviation.

Attributes (Fields)

Attributes are variables inside the class that represent the properties of an object.

class Car {
    String color; // Attribute
    String model; // Attribute
}

Methods

Methods are functions inside a class that define the behavior of an object. For example, a method can make a car start:

void start() {
    System.out.println("Car is starting");
}

Return Types
Methods can return values(int,long,string etc). The void keyword is used when a method doesn’t return anything:
void displayInfo() {
    System.out.println("This is a car.");
}

Access Modifiers
Access modifiers control the visibility of class members. For detailed information, read my blog on Access Modifiers here.

Constructors
A constructor is a special method used to initialize objects. To know more about it read this.

Components of an Object

An object has three main components:

State

The state of an object is defined by its attributes. For example, a car’s color and model define its state.

Behavior

The behavior of an object is defined by its methods. For example, starting and stopping a car are behaviors.

Identity

Each object has a unique identity, which is its reference or memory address in the system.

Example:

class Car {
    String color;
    void displayInfo() {
        System.out.println("Car color: " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.color = "Blue"; // State
        myCar.displayInfo(); // Behavior
    }
}

Special Components of a Class

Static Fields and Methods

Static fields and methods belong to the class, not any specific object. For example:

class MathUtils {
    static int square(int x) {
        return x * x;
    }
}

usage:

int result = MathUtils.square(5); // No object needed

In simple word it means, you do not have to initialize a object to use the static method in a class.

Final Classes and Variables

The final keyword is used to make variables constant, prevent method overriding, or restrict inheritance. This keyword can be used in three context:

final variable => To create constant contact variable.

final method => To prevent method overloading.

final class => prevent inheritance.

final class Constants {
    static final double PI = 3.14159;
}

Advanced Class Concepts

Object Class

Object class in Java is present in java.lang package. Every class in Java is directly or indirectly derived from the Object class. If a class does not extend any other class then it is a direct child class of the Java Object class and if it extends another class then it is indirectly derived. It provides useful methods like:

toString(): Converts an object to a string.
equals(): Checks if two objects are equal.

Builder Classes

Builder classes help create objects step by step, especially when objects have many attributes:

class Student {
    String name;
    int age;

    Student setName(String name) {
        this.name = name;
        return this;
    }

    Student setAge(int age) {
        this.age = age;
        return this;
    }
}

usage:

Student student = new Student().setName("Alice").setAge(20);

Singleton Class
A Singleton class ensures that only one instance of the class is created throughout the program's execution. It is commonly used when you need a single, shared resource, such as a configuration manager or a database connection.

The key steps to create a Singleton class are:

Make the constructor private so no other class can instantiate it.
Create a static method to provide access to the instance.
Use a static field to hold the single instance of the class.

Example:

class Singleton {
    // Step 1: Create a private static instance of the class
    private static Singleton instance;

    // Step 2: Make the constructor private
    private Singleton() {
        System.out.println("Singleton Instance Created");
    }

    // Step 3: Provide a public static method to get the instance
    public static Singleton getInstance() {
        if (instance == null) { // Check if instance is not already created
            instance = new Singleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance(); // Creates the instance
        Singleton obj2 = Singleton.getInstance(); // Returns the same instance

        System.out.println(obj1 == obj2); // Output: true (both refer to the same instance)
    }
}

Explanation:
The constructor is private, so you cannot create an object of Singleton class using new.
The getInstance() method checks if the instance is null. If it is, a new instance is created. Otherwise, the existing instance is returned.
This ensures that only one object is created, no matter how many times getInstance() is called.

In-Built Packages

Packages group related classes. Some common in-built packages in Java include:

java.util: Contains utility classes like ArrayList, HashMap.
java.io: Provides classes for input and output operations.
java.lang: Includes core classes like String, Math.

Example:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        System.out.println(list);
    }
}

Real-Life Applications of Classes and Objects

Student Management: A Student class with attributes like name, age and methods like enroll().

Bank System: A BankAccount class with attributes like balance and methods like deposit(), withdraw().

Conclusion

Classes and objects are fundamental building blocks of object-oriented programming. They help organize code, make it reusable, and represent real-world entities in software. By understanding their components and practicing with small projects, you can lay a strong foundation for mastering object-oriented programming. Happy coding!

Encapsulation and Abstraction in Object-Oriented Programming (OOP)

Aayush Singh — Thu, 26 Dec 2024 12:53:07 +0000

Understanding encapsulation and abstraction is essential when learning Object-Oriented Programming (OOP). These concepts make programs easier to design, read, and maintain. In this article, we will explore these two pillars of OOP step by step in simple terms, using Java examples to clarify the concepts.

Introduction

What Are Encapsulation and Abstraction?

Encapsulation: The process of bundling data (variables) and methods (functions) that operate on the data into a single unit (class) while hiding the implementation details.
Abstraction: The process of exposing only essential features of an object while hiding unnecessary details.

Together, these concepts help developers create more secure, modular, and reusable code.

Encapsulation

Definition and Concept
Encapsulation ensures that the internal details of a class are hidden from the outside world. It protects the data by restricting direct access to class fields and controlling it through methods.

Example:

Imagine a bank account. You can deposit or withdraw money through specific operations, but you cannot directly change the balance without using these operations. This protection is encapsulation.

How Encapsulation Works

Encapsulation is achieved using access modifiers (public, private, protected) to restrict access to class fields and methods.

Access Modifiers:

Private: The field or method can only be accessed within the class.

Public: The field or method can be accessed from anywhere.

Protected: The field or method can be accessed within the class and its subclasses. Here is how encapsulation is implemented:
 class BankAccount {
     private double balance; // Private field
     // Public method to get the balance
     public double getBalance() {
         return balance;
     }
     // Public method to set the balance
     public void deposit(double amount) {
         if (amount > 0) {
             balance += amount;
         }
     }
     public void withdraw(double amount) {
         if (amount > 0 && amount <= balance) {
             balance -= amount;
         }
     }
 }
Getters and Setters
Getters and setters are methods that allow controlled access to private fields. They help protect the data by validating or restricting input and output values.
Example:
class Person {
    private String name; // Private field
    // Getter method
    public String getName() {
        return name;
    }
    // Setter method
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
}

Benefits of Encapsulation

Data Hiding: Prevents unauthorized access to the data.
Improved Modularity: Each class handles its responsibilities.
Easy Maintenance: Changes in the internal implementation do not affect external code.

Abstraction

Definition and Concept

Abstraction focuses on exposing only the essential details of an object while hiding its complexities. For example, when driving a car, you only need to know how to steer and use the accelerator—you don’t need to understand how the engine works internally.

How Abstraction Works
In Java, abstraction is achieved using:

Abstract Classes
Interfaces

Abstract Classes

An abstract class cannot be instantiated. It can have both abstract methods (methods without implementation) and concrete methods (methods with implementation).

Example:

abstract class Animal {
    // Abstract method
    abstract void makeSound();

    // Concrete method
    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound(); // Outputs: Bark
        dog.sleep();     // Outputs: Sleeping...
    }
}

Interfaces

An interface is a blueprint of a class. It contains only abstract methods (until Java 8, where default and static methods are allowed).

Example:

interface Vehicle {
    void start(); // Abstract method
}

class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car is starting...");
    }
}

class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        car.start(); // Outputs: Car is starting...
    }
}

Benefits of Abstraction

Simplifies Code: Focuses only on essential details.
Improves Code Reusability: Abstract methods and interfaces provide reusable templates.
Enhances Flexibility: Allows different implementations for the same behavior

Encapsulation vs. Abstraction

Key Differences

Encapsulation	Abstraction
Hides implementation details.	Hides unnecessary details.
Achieved using private fields.	Achieved using abstract classes or interfaces.
Focuses on how data is accessed.	Focuses on what an object does.

How They Work Together

Encapsulation hides the implementation details of a class.
Abstraction focuses on exposing only essential features.

Example 1: In a banking system:

Encapsulation:

Protect customer details (e.g., account number) using private fields.

Abstraction:

Define operations like deposit() and withdraw() in an interface.

Example 2: Designing a Car Class

Encapsulation:

Hide the details of the engine (e.g., private fields).

Abstraction:

Expose essential methods like start() and stop().

Conclusion

Encapsulation and abstraction are powerful tools in OOP. Encapsulation protects the internal details of a class, while abstraction simplifies complex systems by focusing on essential features. Together, they make code more secure, modular, and maintainable.

As your next step, explore how these concepts are applied in design patterns and frameworks to deepen your understanding of OOP.