Forem: Nadeem Rashid

Git: The Tool Every Developer Needs to Know

Nadeem Rashid — Thu, 20 Mar 2025 05:10:06 +0000

Introduction

In software development, keeping track of code changes and managing different versions of a project is crucial. Git is a powerful tool that helps developers:

Save progress and revisit previous changes.
Collaborate efficiently without overwriting each other’s work.
Manage different versions of a project easily.

With Git, multiple contributors can work on the same project simultaneously. Additionally, platforms like GitHub allow developers to store their projects online, making remote collaboration seamless.

This guide covers Git fundamentals, essential commands, and how to use Git with remote repositories. By the end, you will have a solid foundation for managing code effectively.

Things We Will Learn in This Blog

In this blog, we will dive into the key concepts and commands of Git to help you manage your code and collaborate with others. Here’s what you’ll learn:

What Git is and why it’s important for version control and collaboration.
How to check if Git is installed and how to install it if needed.
How to configure Git with your name and email to track commits.
Key Git terms such as repositories, commits, branches, merges, and remotes.
Git workflow and how changes flow through different stages (working directory, staging area, and local repository).
Basic Git commands for initializing repositories, staging, committing, and pushing changes.
How to work with remote repositories (e.g., GitHub) for collaboration and managing versions.
How to undo changes and fix mistakes using Git’s powerful commands.
How to work with branches to create new features or fixes without affecting the main project.

By the end of this blog, you'll have a comprehensive understanding of Git and how to use it to manage your projects effectively.

What is Git and Why Use It?

Git is a distributed version control system (DVCS) that helps developers manage code efficiently. It allows you to track changes, collaborate with others, and maintain different versions of a project without losing progress.

Key Benefits of Git:

Track Changes – Keep a complete history of modifications.
Collaboration – Work smoothly with multiple developers.
Branching & Merging – Experiment with new features without affecting the main project.
Backup & Recovery – Revert to previous versions if needed.
Industry Standard – Used by companies like Google, Microsoft, and major open-source projects.

By using Git, teams can work together efficiently while keeping their code organized and secure.

Checking if Git is Installed

Before using Git, check if it's already installed on your system. Open a terminal or command prompt and run:

git --version

If Git is installed, it will display something like below

git version 2.45.0.windows.1

If the command does not work, Git is not installed on your system

Installing Git

You can download and install Git from the official website:
Download Git

Configuring Git

After installing Git, you need to set up your username and email. This information is used to track your commits and associate them with you.

Set Your Name and Email

Run the following commands in your terminal or command prompt:

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

Verifying Your Git Configuration

To check if your details were saved correctly, run:

git config --list

This will display a list of all configured settings. You should see your name and email in the output, like this:

user.name=Your Name  
user.email=your.email@example.com

Basic Git Terms

Repository (Repo) – A folder where Git is initialized to track changes in a project.
Commit – A saved version of your project at a specific point in time.
Remote Repository – A version of your repository stored online (e.g., GitHub, GitLab).
Staging Area – An intermediate area where changes are gathered before they are committed to the repository. It allows you to prepare and review changes before finalizing them in a commit.
Branch – A separate line of development that allows you to work on changes without affecting the main project. Useful for adding new features or fixing bugs.

Merge – Combining changes from two different branches into one. For example, adding new features from a feature branch to the main project branch.
Clone – Copying a repository from a remote source to your local machine.
Pull – Getting the latest changes from a remote repository to update your local copy.
Push – Sending your local changes to a remote repository to share with others.

Understanding Git Workflow

Git follows a three-stage process to track and manage code changes efficiently. This workflow ensures that every change is tracked, reviewed, and stored safely before being shared.

The main stages of Git workflow are:

Working Directory – The folder where your project exists and where you modify files.
Staging Area - A temporary space where changes are prepared before committing. This allows you to review modifications before permanently saving them in the local repository.
Local Repository – A hidden .git directory on your computer where committed versions are stored.
Remote Repository – A version of your repository hosted on platforms like GitHub or GitLab, used for collaboration.

Basic Git Workflow

Initialize a repository: git init
Clone an existing repository: git clone <repo-url>
Stage changes:
- git add <file-name>
- git add . (to add all files)
Commit changes: git commit -m "Your message"
Push changes to remote: git push origin <branch-name>
Pull the latest changes: git pull origin <branch-name>

Essential Git Commands

1. Setup & Initialization

Action	Command	Description
Configure Git	`git config --global user.name "Your Name"` `git config --global user.email "your@email.com"`	Set up Git with your name and email.
Initialize a repo	`git init`	Create a new local repository.
Link repo to GitHub	`git remote add origin <repo-url>`	Connect local repo to GitHub.

2. Tracking & Committing Changes

Action	Command	Description
Check status	`git status`	See modified/untracked files.
Stage all changes	`git add .`	Add all modified files to staging.
Stage a specific file	`git add <filename>`	Add a specific file.
Commit changes	`git commit -m "Your message"`	Save changes locally.

3. Pushing Code to GitHub

Action	Command	Description
Push to GitHub	`git push -u origin main`	Upload commits to GitHub.
Push to a different branch	`git push origin <branch-name>`	Push changes to a specific branch.

4. Pulling & Updating Code

Action	Command	Description
Fetch latest changes	`git pull origin main`	Update local repo from GitHub.
Clone a repository	`git clone <repo-url>`	Download a copy of an existing GitHub repo.

5. Undo & Fix Mistakes

Action	Command	Description
Undo last commit (keep changes)	`git reset --soft HEAD~1`	Remove the last commit but keep changes.
Revert to last committed state	`git checkout -- <filename>`	Undo changes in a specific file.
Reset all uncommitted changes	`git reset --hard`	Remove all local changes. ⚠ Be careful!

6. Branching & Merging

Action	Command	Description
Create a new branch	`git branch <branch-name>`	Create a new branch.
Switch branches	`git checkout <branch-name>`	Move to another branch.
Create & switch to a new branch	`git checkout -b <branch-name>`	Create and switch to a new branch.
Merge branches	`git merge <branch-name>`	Merge a branch into the current branch.

Conclusion

Git is an essential tool for every developer, enabling efficient version control and seamless collaboration. By mastering its core concepts and commands, you can streamline your workflow, keep your projects organized, and ensure smooth collaboration.

This blog covered Git fundamentals—from installation to essential commands for tracking, committing, and pushing changes. We also explored working with remote repositories, managing branches, and fixing mistakes. With these skills, you’re ready to manage your codebase and collaborate effectively.

Start using Git today to level up your development process!

How Operating Systems Manage Processes

Nadeem Rashid — Mon, 17 Mar 2025 10:49:09 +0000

Introduction

Our computer is like a battlefield where multiple programs are constantly
fighting for CPU time. Without a proper management system, everything would slow down, freeze, or even crash. Whether you're browsing the web, running apps, or handling background tasks, something needs to decide which process gets priority and how system resources are shared.
This is where the Operating System (OS) comes in—it acts as the ultimate manager, ensuring that every process gets a fair share of CPU time, avoiding conflicts, and keeping the system running smoothly.
But what exactly is a process? Simply put, a process is a running instance of a program. Each process has its own memory, registers, and execution state, allowing multiple processes to run simultaneously without interfering with each other.

What You’ll Learn in This Blog:

What a process is and its lifecycle
How the OS tracks processes using the Process Control Block (PCB)
How process scheduling ensures efficiency
The role of context switching in multitasking
How processes are created, managed, and terminated
Real-world examples of process management

1. What a process is and its lifecycle

A process is an instance of a program in execution. While a program is
just a set of stored instructions (such as a .exe file or a script), it becomes a process when it is loaded into main memory and starts running. So, a process is simply a running program—using CPU time, memory, and system resources to execute its tasks.

However, processes are not limited to just the apps you open. Your Operating System (OS) itself runs multiple background processes to keep your system functional. Some common types of processes include:

System processes – Managing memory, hardware, and security.
Background services – Updating software, syncing files, and running scheduled tasks.
Driver processes – Handling devices like keyboards, printers, and network adapters. Because many processes run at the same time, the OS needs to manage them efficiently to ensure smooth performance and prevent one process from using all the resources.

Understanding the Process Lifecycle:

A process doesn’t simply move from start to finish in a straight path. Instead, it moves through different states based on what it’s doing and what resources it needs. The OS keeps track of these states and transitions to manage CPU time efficiently and ensure fair resource allocation.
Here’s a breakdown of the different process states:
1. New (Created): A process starts in the New state when it is created. At this stage, the OS assigns the necessary memory and resources before it can run.
2. Ready: Once a process is ready to execute, it moves into the Ready state, waiting for the CPU to schedule it. Multiple processes in the ready state form a queue, where the OS decides which one runs next.
3. Running: A process moves to the Running state when it is assigned CPU time and actively executes its instructions. The CPU switches between processes rapidly to maintain multitasking.
4. Waiting (Blocked): A process enters the Waiting state if it needs to wait for something, like user input, disk access, or network data. It remains in this state until the required resource is available.
5. Terminated (Exit): A process reaches the Terminated state when it completes execution or encounters an error. The OS then frees up its resources and removes it from the system.

2. How the OS Tracks Processes Using the Process Control Block

When multiple processes are running, the OS must efficiently track and manage them. This is done using a Process Control Block (PCB), a data structure that stores essential details about each process.

The PCB helps the OS keep track of a process's state, resources, and execution history, ensuring smooth multitasking and process switching.

Key Components of the Process Control Block

Process ID (PID): A unique number assigned to each process for identification.
Process State: Indicates whether the process is in the New, Ready, Running, Waiting, or Terminated state.
Program Counter (PC): Stores the memory address of the next instruction to be executed.
CPU Registers: Hold temporary data, execution-related information, and process-specific variables.
Memory Information: Contains details about the memory allocated to the process, including the address space.
I/O Information: Tracks the input/output devices and files the process is interacting with.
Priority: Determines the scheduling priority of the process, deciding how soon it gets CPU time. The OS updates the PCB dynamically as a process moves through different states. This allows seamless switching between processes and efficient resource allocation.

Transition to Process Scheduling

Tracking processes is just the first step—next, the OS must decide which process should run and when. That’s where Process Scheduling comes into play. Let’s dive in!
Since multiple processes compete for execution, the OS must schedule them efficiently to maintain system performance and responsiveness. This is where process scheduling plays a crucial role.

Illustration of a Process Control Block

3. How Process Scheduling Ensures Efficiency

Now that we understand how the OS tracks processes using the Process Control Block (PCB), the next challenge is determining which process gets CPU time and when. Since multiple processes compete for execution, the OS must schedule them efficiently to maintain system performance and responsiveness.
To achieve this, the OS follows three levels of scheduling:

Long-Term Scheduling: Decides which processes are admitted into the system for execution, helping manage the overall system workload.
Short-Term Scheduling: Determines which process runs next, using scheduling algorithms like First-Come-First-Serve (FCFS), Round Robin, and Priority Scheduling to optimize performance.
Medium-Term Scheduling: Temporarily suspends (or swaps out) processes to free up memory and improve efficiency, particularly in virtual memory systems.

4. Context Switching: The Backbone of Multitasking

Context switching is how the OS quickly switches between processes, keeping multitasking smooth. But every switch comes with a cost—since the CPU spends time saving and loading process states instead of executing tasks.
How Context Switching Works:

Interrupt or System Call: A running process (P₀) gets interrupted (e.g., time slice ends, higher-priority process needs CPU).
Save Current Process State: The OS stores P₀'s execution details (program counter, registers, etc.) in its Process Control Block (PCB₀).
Load the Next Process: The OS retrieves P₁’s saved state from PCB₁ and restores its execution context.
Resume Execution: P₁ starts running while P₀ stays idle.
Repeat: When it’s time to switch back, the OS repeats the process, saving P₁’s state and restoring P₀’s.

5.Process Creation & Termination

Every process in an operating system starts somewhere. But how exactly are processes created? And once they complete their tasks, how does the OS handle their termination?

Process Creation: How New Processes Start A new process is typically created when a user runs a program or when an existing process spawns a child process. This parent-child relationship allows complex applications to break tasks into multiple subprocesses, improving efficiency. In UNIX-based operating systems, processes are created using the fork() system call. This function duplicates the calling (parent) process, creating a new (child) process with an identical memory space.
Example: Process Creation Using fork() in C: Given below is the simple example which shows how a process creates a child process using fork() in C:

#include <stdio.h>    
#include <unistd.h>   // Provides access to the fork() system call
int main() {
    // Creating a child process using fork()
    int pid = fork(); 
    // fork() returns:
    // > 0  → to the parent process (the returned value is the child's PID)
    // == 0 → to the child process
    // < 0  → if fork() fails (error case)
    if (pid > 0) {
        // This block runs in the **parent process**
        printf("Parent Process: PID = %d, Child PID = %d\n", getpid(), pid);
    } 
    else if (pid == 0) {
        // This block runs in the **child process**
        printf("Child Process: PID = %d, Parent PID = %d\n", getpid(), getppid());
    } 
    else {
        // If fork() fails, an error message is displayed
        printf("Fork failed! Unable to create a new process.\n");
    }
    sleep(30);  // Keep the process running for 30 seconds
    return 0; // Exit the program successfully
}

Process Termination: How Processes End A process can terminate in various ways:
1. Normal termination: When the process completes execution and exits gracefully.
2. Abnormal termination: If an error occurs, causing the process to stop unexpectedly.
3. Killed by another process: A process can be forcefully stopped using the kill command in UNIX/Linux.
Example: Killing a Process in Linux
Find the process ID (PID) using:
```
ps aux | grep process_name
```

Kill the process using:
```
kill -9 PID
```

6 Real-World Use Cases & Examples

Process management isn't just a theoretical concept—it plays a crucial role in real-world applications. Let’s explore two well-known examples:
**1. Google Chrome: Multi-Process Architecture
Have you ever noticed that when one Chrome tab crashes, the whole browser doesn’t? That’s because it follows a multi-process model, where:

Each tab runs as a separate process → A crash in one tab doesn’t affect others.
Plugins and extensions have their own processes → Improves security and isolation.
Processes run in a sandbox → Prevents malware from spreading to the OS. We can observe this by opening Chrome’s built-in Task Manager: Open Google Chrome. Press Shift + Esc (Windows) or go to Menu > More Tools > Task Manager. You can see each tab, extension, and service listed as a separate process. Here's an example of what it looks like: In the above image, we can see multiple processes running, such as:
Browser process (Main UI)
GPU process (Handles graphical rendering)
Network service (Manages internet connections)
Tabs running as separate processes (e.g., Diffchecker tab)
Multiple subframe processes (for ads, embedded content, etc.) 2. Linux: Managing System Processes with systemd Linux follows a hierarchical process management model, where system processes are initialized by **systemd or init. These processes handle everything from launching system services to managing user applications. Key Linux System Processes: systemd - The first process started at boot, managing all other processes. cron - Handles scheduled tasks (e.g., backups, script execution). sshd - Manages remote SSH connections. Xorg - Provides graphical display services. To view top 10 running processes in Linux, run the below command:

ps aux | head -10

For a real-time view, run the below command:

top

7 Conclusion

Behind every smooth computing experience lies the OS’s powerful process management system—silently juggling multiple programs, allocating resources, and ensuring everything runs without chaos. Without it, even the most advanced systems would struggle to keep up.

Key Takeaways:

Every process follows a lifecycle, transitioning through different states.
The OS tracks each process using a Process Control Block (PCB) to store vital execution details.
CPU scheduling ensures fair resource distribution, optimizing performance.
Context switching keeps multitasking smooth by rapidly switching between active processes.
Processes are created and terminated dynamically, adapting to system needs.
Real-world applications like Chrome’s multi-process model and Linux’s system management highlight its importance.

Final Thought

Next time you open multiple applications, pause for a moment—how does your OS decide which one gets CPU time first? The answer lies in CPU Scheduling, a key concept we’ll explore in the next blog!

What’s your biggest question about OS process management? Drop a comment below, and let’s discuss! 🚀

Bit Manipulation In Problem Solving

Nadeem Rashid — Wed, 25 Dec 2024 10:46:29 +0000

In programming, efficiency is crucial, and bit manipulation is one of the most powerful techniques for achieving it. At the core of every computer, data is represented as binary sequences of 0's and 1's — bits. Directly manipulating these bits allows you to optimize performance, save memory, and simplify algorithms, often achieving faster and more space-efficient solutions than traditional methods. Bit manipulation is especially useful in competitive programming, embedded systems, and scenarios where performance is a priority. In this blog, we’ll explore the essential bit manipulation operations and demonstrate how to apply them in problem-solving, helping you sharpen your coding skills and tackle challenges more effectively.

Basic Bit Manipulation Operations

1.AND (&):
Compares two bits and returns 1 if both are 1, otherwise it returns 0.

X	Y	X & Y
0	0	0
0	1	0
1	0	0
1	1	1


 Example:
 a = 10001
 b = 11111
 a & b = 10001

2.OR (|):
Compares two bits and returns 1 if atleast one of the bits is 1 , otherwise it produces 0.

X	Y	X \| Y
0	0	0
0	1	1
1	0	1
1	1	1

 Example:
 a = 10001
 b = 11111
 a | b = 11111

3.NOT (~):
It changes 1 to 0 and vice versa.

X	~X
0	1
1	0

Example:  
a = 10001  
~a = 01110

4.Left Shift (<<):
Left shift moves bits to the left, filling the rightmost positions with zeros. This is equivalent to multiplying by 2 for each shift.

Example:  
a = 5 (in binary: 101)  
a << 2 = 10100 (which equals 20, i.e., 5 * 2 * 2 = 20)

5.Right Shift (>>):

Right shift moves bits to the right, which is equivalent to division by 2 for each shift.

Example:  
a = 5 (in binary: 101)  
a >> 2 = 1 (which equals 1, i.e., 5 / 2 / 2 = 1)

6.XOR (^):
XOR compares the bits and returns 1 if the bits are different, and 0 if the bits are the same. XOR is often called the "odd 1 detector."

X	Y	X ^ Y
0	0	0
0	1	1
1	0	1
1	1	0

Now that we've covered the basics of bit manipulation, let's apply these operations to solve some common problems. Below are some examples and their solutions.

1. Check If a Number Is Odd or Even

Problem Description:
To determine if a number is odd or even, we use a bitwise AND operation with 1. If the least significant bit (LSB) is 1, the number is odd; if it is 0, the number is even.

Approach:
Perform num & 1.
If the result is 0, the number is even.
If the result is 1, the number is odd.

num = int(input("Enter a number: "))
if num & 1:
    print("Odd")
else:
    print("Even")

2. Count the Number of 1's in a Binary Representation of a Number

Problem Description:
This approach repeatedly checks the LSB of the number using the bitwise AND operation with 1. Each time a 1 is found, we increment the count. The number is right-shifted in every iteration until all bits are processed.

Approach:
Keep shifting the number right while checking the LSB.
Count the number of times the LSB is 1

def countOnes(num):
    count = 0
    while num:
        count += (num & 1)
        num >>= 1
    return count

num = int(input("Enter a number: "))
print(f"Number of 1s: {countOnes(num)}")

3. Check If a Number Is a Power of 2:

Problem Description:
A number is a power of two if it has exactly one bit set in its binary representation. Using the condition num & (num - 1), we can clear the rightmost set bit and check if the result is 0.

Approach:
Perform num & (num - 1).
If the result is 0 and the number is greater than 0, the number is a power of 2.

def isPowerOfTwo(num):
    return num > 0 and (num & (num - 1)) == 0

num = int(input("Enter a number: "))
if isPowerOfTwo(num):
    print("Power of 2")
else:
    print("Not a power of 2")

print(f"Number of 1s: {countOnes(num)}")

4. Change the Bit of a Number at a Particular Position:

Problem Description:
To modify a bit at a specific position in a number, we use bitwise OR to set the bit to 1 and bitwise AND with a complemented mask to set the bit to 0. This allows precise control over the binary representation of the number.
Approach:
Use the bitwise OR operation to set a bit to 1.
Use the bitwise AND operation with the complement to set a bit to 0.


def changeBit(num, pos, bit):
    if bit == 1:
        num |= (1 << pos)  # Set bit to 1
    else:
        num &= ~(1 << pos)  # Set bit to 0
    return num

num = int(input("Enter a number: "))
pos = int(input("Enter position of bit to change: "))
bit = int(input("Enter the bit value (0 or 1): "))
num = changeBit(num, pos, bit)
print(f"Updated number: {num}")

5. Find the Single Number in an Array:

Problem Description:
When every element in an array appears exactly twice except for one, XOR operation can help identify the unique element. XOR cancels out duplicate values, leaving only the single number.
Approach:
Use XOR to cancel out duplicate elements. Since 𝑎⊕𝑎=0,
and 𝑎⊕0=𝑎, XORing all elements will leave only the unique number.


def findSingleNumber(arr):
    result = 0
    for num in arr:
        result ^= num
    return result

size = int(input("Enter the size of the array: "))
arr = [int(input(f"Enter element {i + 1}: ")) for i in range(size)]
print(f"Single number: {findSingleNumber(arr)}")

6. Check Whether Two Numbers Have Opposite Signs:

Problem Description:
The XOR operation can determine if two numbers have opposite signs by checking the sign bit. If the result of XOR is negative, the numbers have opposite signs.

Approach:
Use XOR: if the result is negative, the numbers have opposite signs.

def haveOppositeSigns(a, b):
    return (a ^ b) < 0

a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
if haveOppositeSigns(a, b):
    print("Opposite signs")
else:
    print("Same sign")

7. Swap Two Numbers Without Using a Temporary Variable:

Problem Description:
Swapping two numbers without using extra memory can be achieved using the XOR operation. It allows the values to be exchanged in-place through three XOR operations.
Approach:
Use XOR to swap two numbers.

def swap(a, b):
    a ^= b
    b ^= a
    a ^= b
    return a, b

a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
a, b = swap(a, b)
print(f"Swapped: a = {a}, b = {b}")

8. Reverse the Bits of a Number:

Problem Description:
Reversing the bits of a number involves iteratively shifting the bits to construct the reversed number while extracting bits from the original number.

Approach:
Use bitwise shifts and OR to reverse the bits.

def reverseBits(num):
    reversed = 0
    while num:
        reversed = (reversed << 1) | (num & 1)
        num >>= 1
    return reversed

num = int(input("Enter a number: "))
print(f"Reversed bits: {reverseBits(num)}")

Conclusion

Bit manipulation is a powerful technique that allows you to solve problems efficiently by working directly with binary representations of numbers. Mastering these fundamental operations can significantly improve your problem-solving skills, especially when working with time and memory constraints.

For more examples and detailed code snippets, feel free to explore the repository where these problems and solutions are implemented: BitManipulation_Github

nextjs

Nadeem Rashid — Wed, 25 Dec 2024 09:09:42 +0000