Forem: Meerthika

How to restore files entirely from a commit in Git?

Meerthika — Tue, 04 Nov 2025 15:22:56 +0000

I was working on my Spring Boot app when I accidentally moved the folder that contained the Git repository into another directory. When I tried to load it in Spring Tools Suite (STS), the IDE — due to its workspace cache — treated it as a new project. Not realizing this, I deleted the “new” project from the workspace, and all the changes I had made were gone.

I tried pulling it from the remote repository, but the local folder was missing.

So, I decided to restore the files from an earlier commit in my GitHub repository — before I made the mistake.

This is how I did it!

Step 1: Make sure you’re on the main branch

git checkout master
(or git checkout main depending on your branch name)

Step 2: Create a new branch to restore from old commit

This protects your current branch from overwriting.

git checkout -b restore-old-version

Step 3: Restore specific files or folders from a certain commit

Example (restoring only src/ folder):

git restore --source <commit-id> -- src/

This brings the src/ files from that commit into your working directory.

Step 4: Commit the restored files

git add src/
git commit -m "Restore src folder from commit <commit-id>"

Now you’ve captured that state safely in a separate branch.

Step 5: Compare or merge into main

To see what changed before merging:

git diff master

If it looks good:

git checkout master
git merge restore-old-version

Now the restored files are merged into your main branch.

Common Mistakes to Avoid

Using git checkout directly Puts you in detached HEAD → changes not saved to any branch
Skipping git add/commit after restore You’ll lose the restored files when switching branches
Running restore from the wrong branch May restore files to the wrong context or overwrite changes

(Quick Restore without Branch)

If you’re sure you just want to bring back files directly into your current branch:


git restore --source <commit-id> -- src/
git add src/
git commit -m "Restore deleted src folder from <commit-id>"

Simpler, but not reversible as cleanly as using a temporary restore branch.

Go-Scheduler: Understanding Why Goroutines Are So Lightweight

Meerthika — Tue, 06 May 2025 01:28:15 +0000

Goroutines in Go are famously lightweight — much more so than OS threads or traditional language-level threads like those in Java or C++. But what makes goroutines so efficient and scalable? The secret lies in Go’s runtime scheduler.

In this blog, we’ll explore the core concepts behind Go’s concurrency model by diving deep into the Go Scheduler — the engine that powers millions of goroutines behind the scenes. We’ll look at how it works, why it’s different from thread-based models, and how features like M:N scheduling, work-stealing, preemption, and network polling all work together to make Go a concurrency powerhouse.

🧵 Why Are Goroutines So Lightweight?

At a high level:

🪶 Goroutines start with very small stacks (as little as 2KB), which grow and shrink dynamically.
🔄 They are multiplexed onto a smaller set of OS threads, instead of 1:1 mapping.
🧠 The Go runtime manages scheduling — avoiding OS-level context-switching overheads.

This efficiency is made possible by the Go scheduler, a core part of the Go runtime.

⚙️ The M:N Scheduling Model

Go uses an M:N model to schedule goroutines:

M (Machine): an OS thread
P (Processor): a logical processor
G (Goroutine): a lightweight task

📌 How it works:

Each P holds a queue of G (goroutines).
A P must have an M to execute the goroutines.
If a goroutine blocks (on I/O, syscall), its M detaches from P, and another M is scheduled.

🔁 Lifecycle of a Goroutine

A goroutine can be in one of the following states:

State	Description
Runnable	✅ Ready to run, waiting for a `P`
Running	🚀 Actively executing on a `P`
Waiting	⏳ Blocked on I/O, syscall, channel, etc.
Dead	⚰️ Finished execution

🔍 The scheduler tracks these using:

✅ Local run queues per P
🌍 A global run queue for overflow
🌐 Network pollers for I/O-bound goroutines

🔄 Work Stealing

To keep CPUs busy and avoid idling:

Every P has its own local run queue.
If a P runs out of work, it steals goroutines from another P.

💡 This strategy uses lock-free and atomic operations for efficiency and minimal overhead.

⏱️ Preemptive Scheduling

Go initially used cooperative scheduling (goroutines yielded at safe points like function calls).

🚀 From Go 1.14+, preemptive scheduling was introduced:

The runtime injects asynchronous preemption signals.
Prevents a goroutine from hogging the CPU.
Increases fairness and responsiveness across the system.

🔧 Handling Syscalls and Blocking I/O

Go handles blocking calls smartly:

When a goroutine makes a blocking syscall, its M is detached.
Another M is assigned to the P so that other goroutines can continue running.
Once the blocking call completes, the goroutine re-enters the scheduling system.

🔋 This keeps the system non-blocking and highly scalable.

🌐 Network Polling

For efficient I/O, Go uses OS-specific mechanisms:

🐧 epoll on Linux
🍎 kqueue on macOS/BSD
🪟 IOCP on Windows

A dedicated M (OS thread) watches for I/O readiness:

🛌 Sleeps until network events occur
🔔 Wakes the appropriate goroutines
🔄 Allows zero scheduler blocking

🚀 The `Custom`Go Scheduler

func (s *Scheduler) RunMachine(m *M) {
    m.running = true // assign a kernel thread
    m.boundP = s.Ps[m.id % len(s.Ps)] // static round-robin
    p := m.boundP

    fmt.Printf("M[%d] BOUND to P[%d]\n", m.id, p.id)

    var g *G // Assigned goroutine

    for {
        select {
        case g = <-p.runQueue:
        case g = <-s.globalQueue:
        default:
            // Work stealing from other Ps
            for _, otherP := range s.Ps {
                if otherP.id != p.id {
                    select {
                    case g = <-otherP.runQueue:
                        fmt.Printf("M[%d] STEALING FROM P[%d]\n", m.id, otherP.id)
                        goto EXEC
                    default:
                    }
                }
            }

            // Network Polling
            select {
            case g = <-s.networkPoller:
                fmt.Printf("M[%d] WOKE G[%d] NETWORK POLLER\n", m.id, g.id)
                goto EXEC
            default:
            }

            // Sleep to avoid busy waiting
            time.Sleep(10 * time.Millisecond)
            continue
        }

    EXEC:
        g.state = "running"
        fmt.Printf("[State] G[%d] state changed to RUNNING by M[%d]\n", g.id, m.id)

        done := make(chan struct{})

        go func() {
            if rand.Intn(10) < 2 {
                fmt.Printf("[SysCall] G[%d] performing BLOCKING syscall\n", g.id)
                g.state = "blocked"
                s.blockedG <- g
                return
            }
            g.task()
            close(done)
        }()

        select {
        case <-done:
            fmt.Printf("[State] G[%d] finished\n", g.id)
        case <-time.After(100 * time.Millisecond):
            fmt.Printf("[Preempt] G[%d] preempted\n", g.id)
            g.state = "runnable"
            p.runQueue <- g
        }
    }
}

🔧 RunMachine Explained

This function represents an OS thread (M) executing goroutines (G) bound to a logical processor (P). Here's the high-level idea:

Each M is statically bound to a P using round-robin.
Goroutines are fetched from:
- The bound P’s run queue
- The global queue
- Other P’s queues (via work stealing)
- The network poller queue
Tasks may be preempted or blocked (e.g., on syscall).
Syscalls detach M from G, and reschedule work on the same P.

Output

M[0] BOUND to P[0]
M[1] BOUND to P[1]
M[2] BOUND to P[0]
M[2] WOKE G[10] NETWORK POLLER
[State] G[10] state changed to RUNNING by M[2]
[SysCall] G[10] performing BLOCKING syscall
[Preempt] G[10] preempted
[SyscallReturn]: G[10] returning from Syscall

M[0] WOKE G[11] NETWORK POLLER
[State] G[11] state changed to RUNNING by M[0]
[NetPoll]: Handling network Event
[State] G[11] finished

M[1] WOKE G[12] NETWORK POLLER
[State] G[12] state changed to RUNNING by M[1]
[NetPoll]: Handling network Event
[State] G[12] finished

🧾 Conclusion

Go’s scheduler is what allows it to scale thousands or even millions of goroutines with minimal resource usage.

Whether you're:

Running concurrent web servers
Managing network services
Building real-time systems

Goroutines and the Go Scheduler ensure scalability, responsiveness, and developer simplicity.

If you liked this post, give it a ❤️ or 🦄, and leave your thoughts or questions below!

➡️ Code Repo: github.com/mery-top/GO-Scheduler

➡️ Proc.go Source Code: Go Runtime Scheduler Source

Routing

Meerthika — Fri, 25 Apr 2025 14:34:34 +0000

In this blog, we’ll dive deep into how routing works — the mechanism that powers the journey of data packets across the internet. We'll also create a simple Static Router simulation using Go (Golang).

🌍 What is Routing?

Routing is the process of determining the best path for data packets to travel from a source device to a destination device across interconnected networks.

📌 Operates at Layer 3 (Network Layer) of the OSI Model

📡 Protocol: IP (Internet Protocol)

🔌 Device: Router

🧠 Routing focuses on forwarding IP packets, not the actual physical movement of data.

🛣️ Types of Routing

1️⃣ Static Routing

🧑‍💻 Manually configured by network admins
✅ Best for small, stable networks
🔁 Doesn’t adapt to network changes

ip route add 10.0.0.0/24 via 192.168.1.1

2️⃣ Dynamic Routing

🤖 Routers communicate automatically using routing protocols.
🔁 Routes are updated based on network topology changes.

Protocols and Use Cases

Protocol	Use Case
RIP, OSPF	Internal networks (IGP)
BGP	Between ISPs (EGP)

🔁 Key Concepts in Routing

Term	Meaning
Router	Device that forwards packets between networks
Next Hop	IP of the next router for forwarding the packet
Routing Table	Maps destination networks to next hops
Metric	Used to select the best path (cost, delay, etc.)
CIDR/IP Prefix	Defines IP ranges (e.g., 192.168.0.0/16)

🌐 Static Routing in Go 🧑‍💻

Let’s simulate packet forwarding using static routes in Go!

package main

import (
    "fmt"
)

type Packet struct{
    Source string
    Destination string
    Data string
}

type RoutingTable map[string]string

func(p *Packet) String() string{
    return fmt.Sprintf("Packet: Source: %s, Destination: %s, Data: %s \n", p.Source, p.Destination, p.Data)
}

func (rt RoutingTable )GetnextHop(destination string) string{
    nextHop, exists:= rt[destination]
    if exists{
        return nextHop
    }
    return "No Route Found"
}


func ForwardPacket(p *Packet, routingTable RoutingTable){
    nextHop:= routingTable.GetnextHop(p.Destination)
    fmt.Printf("The NextHop is %s\n", nextHop)
    fmt.Println(p)
}


func main(){
    router1RoutingTable:= RoutingTable{
        "192.168.1.2" : "Router2",
    }

    router2RoutingTable:= RoutingTable{
        "192.168.1.2": "Final Destination",
    }

    packet:= &Packet{
        Source: "192.168.1.1",
        Destination: "192.168.1.2",
        Data: "Hello, This is a Packet",
    }

    fmt.Println("Router table 1")
    ForwardPacket(packet, router1RoutingTable)
    fmt.Println("Router table 2")
    ForwardPacket(packet, router2RoutingTable)
}

🚦 How Dynamic Routing Works

Unlike static routing, dynamic routing enables routers to:

📬 Exchange network info
🔁 Automatically update routing tables
⚡ Adapt to topology changes

🔑 Key Concepts

Concept	Explanation
Routing Protocols	RIP, OSPF, BGP used to exchange route info
Metric	Helps pick best route (e.g., speed, hops)
Continuous Updates	Ensures routing tables reflect current topology
Auto Adjustments	Quick rerouting in case of failures

🧠 Types of Dynamic Routing Protocols

🟦 1. Distance Vector

📌 Shares entire routing table with neighbors
🔢 Decision: based on hop count
⚠️ Risk: Routing loops, slow convergence

✅ Examples:

RIP – Simple, max 15 hops
IGRP – Cisco, uses bandwidth & delay

🟩 2. Link State

📌 Each router builds full topology
📡 Shares info about directly connected links only
⚡ Fast convergence, great for large networks

✅ Examples:

OSPF – Efficient, hierarchical
IS-IS – Used by ISPs

🟨 3. Hybrid

📌 Mix of distance vector & link state
📈 Updates only on change
⚙️ Uses DUAL algorithm for fast, loop-free recovery

✅ Example:

EIGRP (Cisco proprietary)

🟥 4. Path Vector

📌 Used between organizations (EGP)
🌍 Tracks the full AS path
🧠 Policy-based decision making

✅ Example:

BGP – The Internet's main routing protocol

🧾 Conclusion

Routing is at the heart of networking, guiding how data flows across the globe 🌐.

Whether it's static (manually set routes) or dynamic (intelligent, adaptable protocols), routers ensure data finds its way efficiently. 🛰️

And with just a few lines of Go, we built a basic simulation of how a router decides the next hop for a packet. 🧑‍💻

If you enjoyed this post, give it a ❤️ or 🦄 and share your thoughts in the comments!

Happy networking! 🌐✨

Subnets

Meerthika — Fri, 25 Apr 2025 00:16:08 +0000

In this blog, I’ll break down subnetting, show you how it works, and walk you through my subnetting project (complete with diagrams and code).

Let’s untangle the magic behind those /24, /16, and 255.255.255.0 masks. 🎭

🚦 Why Subnetting Matters

"Without subnetting, your network’s like a city with no street names — total chaos."

Imagine 10,000 devices trying to talk on the same street with no addresses. That’s what a flat IP network looks like.

Subnetting introduces:

📦 Structure
🚀 Routing efficiency
🔐 Security boundaries

Let’s break it down 👇

🌐 What is a Subnet?

A subnet (short for subnetwork) is a smaller network within a larger one, created by dividing an IP range using a subnet mask.

For example:

🧮 IP Address: 135.70.1.0

🎭 Subnet Mask: 255.255.255.0

We’re saying:

First 3 octets = Network
Last octet = Hosts

This helps:

Routers 🚚 know where to send packets
Admins 🧑‍💻 manage traffic flow between devices and regions

🧩 How Subnetting Works

A subnet mask splits the IP address into:

🧱 Network bits — define the subnet
🏠 Host bits — define the actual devices

Think of each subnet like a neighborhood in a city:

Devices (houses) are easier to locate, control, and communicate within that area 🏡

📸 Visual Aid:

🔢 IPv4 Classes and Subnet Masks

Here’s a handy chart that shows the basics of IPv4 classes:

🏷️ Class	🛡️ Subnet Mask	🔁 # of Networks	👥 Hosts per Network
A	`255.0.0.0`	`128 networks`	`16,777,216 hosts`
B	`255.255.0.0`	`16,384 networks`	`65,536 hosts`
C	`255.255.255.0`	`2,097,152 networks`	`256 hosts`

🔍 These classes define how many networks and hosts you can support. For example, Class C is often used in homes and small offices!

🛠️ How I Built My Own Subnet Planner in Go

Ever wanted to divide networks smartly for homes, offices, or cafés? 🍵🏢🏡

I created a Subnet Calculator in Go that:

✅ Accepts an IP address and the desired number of subnets
🧮 Calculates the new subnet mask
✂️ Splits the network accordingly
🔍 Shows usable ranges for each area

⚙️ Go Code: Subnet Planner

package main

import (
    "net"
    "fmt"
)

func main() {
    _, ipNet, err := net.ParseCIDR("192.168.0.0/16")
    baseIP := ipNet.IP
    oldPrefix, _ := ipNet.Mask.Size()

    if err != nil {
        panic(err)
    }

    newPrefix := 24
    numSubsets := 1 << (newPrefix - oldPrefix)

    var subnets []net.IPNet

    for i := 0; i < numSubsets; i++ {
        subnetIP := make(net.IP, len(baseIP))
        copy(subnetIP, baseIP)

        subnetIP[2] = byte(i)
        subnet := net.IPNet{
            IP:   subnetIP,
            Mask: net.CIDRMask(newPrefix, 32),
        }
        subnets = append(subnets, subnet)
    }

    areas := []string{"🏠 home", "🏢 office", "☕ cafe", "🌳 park", "📚 library"}

    for i, area := range areas {
        if i < len(subnets) {
            fmt.Printf("%-10s : %s\n", area, subnets[i].String())
        }
    }
}

This prints subnet blocks for each area like:

🏠 home : 192.168.0.0/24
🏢 office : 192.168.1.0/24
☕ cafe : 192.168.2.0/24
🌳 park : 192.168.3.0/24
📚 library : 192.168.4.0/24

✅ Conclusion

Subnetting isn’t just for network engineers — it’s for anyone building smart systems.

Whether you’re setting up:

💻 A small office LAN
🏫 A school Wi-Fi plan
☁️ A cloud VPC setup

Subnetting gives you:

📶 Scalability
🔐 Security zones
🚀 Faster routing

And hey, once you get the hang of it — it’s kinda fun 😎

Forem: Meerthika

How to restore files entirely from a commit in Git?

Step 1: Make sure you’re on the main branch

Step 2: Create a new branch to restore from old commit

Step 3: Restore specific files or folders from a certain commit

Step 4: Commit the restored files

Step 5: Compare or merge into main

Common Mistakes to Avoid

(Quick Restore without Branch)

Go-Scheduler: Understanding Why Goroutines Are So Lightweight

🧵 Why Are Goroutines So Lightweight?

⚙️ The M:N Scheduling Model

🔁 Lifecycle of a Goroutine

🔄 Work Stealing

⏱️ Preemptive Scheduling

🔧 Handling Syscalls and Blocking I/O

🌐 Network Polling

🚀 The CustomGo Scheduler

🔧 RunMachine Explained

Output

🧾 Conclusion

Routing

🌍 What is Routing?

🛣️ Types of Routing

1️⃣ Static Routing

2️⃣ Dynamic Routing

Protocols and Use Cases

🔁 Key Concepts in Routing

🌐 Static Routing in Go 🧑‍💻

🚦 How Dynamic Routing Works

🔑 Key Concepts

🧠 Types of Dynamic Routing Protocols

🟦 1. Distance Vector

🟩 2. Link State

🟨 3. Hybrid

🟥 4. Path Vector

🧾 Conclusion

Subnets

🚦 Why Subnetting Matters

🌐 What is a Subnet?

🧩 How Subnetting Works

🔢 IPv4 Classes and Subnet Masks

🛠️ How I Built My Own Subnet Planner in Go

⚙️ Go Code: Subnet Planner

✅ Conclusion

🚀 The `Custom`Go Scheduler