DEV Community: dravid p a

Understanding Why `main` and `dev` Diverged

dravid p a — Sun, 21 Jun 2026 12:52:22 +0000

Scenario

You were working on the dev branch.

While you were making commits locally, someone (or you) also made changes directly to the main branch on GitHub.

As a result, both branches moved forward independently.

What Happened?

Initial State

A (common commit)
│
├── main
└── dev

Both branches point to the same commit.

Changes Added to Main

A ── B ── C   (main)
│
└───────────  (dev)

Example:

B = README update
C = CodeQL update

Changes Added to Dev

A ── B ── C          (main)
│
└── D ── E ── F      (dev)

Example:

D = Base crawler
E = Class-based crawler
F = Concurrency implementation

Now both branches contain unique commits.

This situation is called:

Branches have diverged.

Why `git pull main` Did Not Work

Many developers think:

git pull main

means:

"Pull changes from main branch"

But Git interprets it differently.

main is only a local branch name.

Git expects:

git pull <remote> <branch>

Example:

git pull origin main

Where:

origin = GitHub repository
main = branch on GitHub

Correct Way to Update Dev

While on the dev branch:

git fetch origin
git merge origin/main

What Does `git fetch` Do?

git fetch origin

Downloads the latest information from GitHub.

Before fetch:

Local Git:
main -> C

GitHub:
main -> G

After fetch:

main         -> C
origin/main  -> G

Git now knows about the latest remote commits.

No files are changed yet.

What Does `git merge origin/main` Do?

git merge origin/main

Git combines:

dev
+
latest main

Before merge:

A ── B ── C          (origin/main)
│
└── D ── E ── F      (dev)

After merge:

A ── B ── C
│         \
│          M      (dev)
│         /
└── D ── E ── F

M = Merge Commit

Now dev contains:

All main changes
All dev changes

If Merge Conflicts Occur

Git may stop and show:

CONFLICT

Example:

Both branches modified:

README.md

Git cannot decide which version to keep.

You must manually fix the file.

After fixing:

git add .
git commit

Git creates the merge commit.

Push Updated Dev

git push origin dev

Now GitHub receives the merged version.

main -> C

dev -> M

Create Pull Request

dev  --->  main

GitHub PR contains:

README updates
CodeQL updates
Crawler changes
Concurrency changes

Everything together.

Alternative Workflow

You may also update your local main first.

git checkout main
git pull origin main

git checkout dev
git merge main

git push origin dev

Result:

latest main
+
latest dev
=
updated dev

Simple Mental Model

Think of branches as two roads.

            main road
          B ── C
         /
A
         \
          D ── E ── F
            dev road

Both roads started from the same place.

Before creating a Pull Request, connect the roads:

            B ── C
           /      \
A                 M
           \      /
            D ── E ── F

Now everything is connected.

Safe Workflow Summary

git checkout dev

git fetch origin
git merge origin/main

# fix conflicts if needed

git add .
git commit

git push origin dev

Create PR:

dev → main

This is the safest and most common workflow when main and dev have diverged.

A Discord Group Accessed a Restricted AI That Finds Zero-Day Bugs -Here’s How It Happened

dravid p a — Sun, 26 Apr 2026 00:52:48 +0000

🚨 This is NOT a typical “AI breach” this is worse.

A small Discord group just got unauthorized access to one of the most powerful AI security tools ever built.

Let that sink in.

This isn’t just any AI.
This model (Mythos) is designed to:

→ Find zero-day vulnerabilities
→ Break down operating systems & browsers
→ Potentially simulate real cyberattacks

And it was supposed to be highly restricted.

🧠 What actually happened?

A few users from a private Discord group gained access
Not through advanced hacking… but through:
- Contractor access loopholes
- Smart guessing (internal URLs, patterns)
- Public data scraping (GitHub, OSINT tools)

👉 No direct breach of core systems
👉 The weakness? Third-party access

⚠️ Why this is a BIG deal

This AI can:

Discover critical bugs faster than humans
Expose weaknesses in widely used software
Potentially accelerate cyberattacks

Now imagine that in the wrong hands.

🤯 The most important insight

Everyone will focus on:
“AI tool fell into the wrong hands”

But the real problem is:

Even the most restricted, powerful AI systems are only as secure as their weakest access point.

Not the model.
Not the infrastructure.
But the people + ecosystem around it.

🌍 Who should care?

Tech companies 🏢
Governments 🏛️
Developers 👨‍💻
Basically… anyone using software (so, everyone)

🧩 Current status

Investigation is ongoing
No confirmed large-scale damage (yet)
Some viral claims were fake / AI-generated

But one thing is clear 👇

⚡ Final thought

We’re entering a world where:

👉 AI can find and exploit vulnerabilities in hours
👉 And access control failures can expose it in minutes

The question isn’t “if” this happens again…
It’s “how prepared are we when it does?”

💬 What do you think is AI making cybersecurity stronger or more dangerous?

JavaScript: Single-Threaded but Asynchronous - How Does It Work?

dravid p a — Tue, 15 Jul 2025 15:23:45 +0000

JavaScript is often described as a single-threaded language, yet it can handle asynchronous operations seamlessly. This might sound contradictory at first, but understanding how JavaScript achieves this is crucial for every developer. Let's break it down with clear examples.

What is a Thread?

A thread is an independent sequence of execution within a program. Think of it as a worker that can execute code line by line. Each thread has its own call stack and can run independently.

// Imagine this as a single worker (thread) executing tasks
console.log("Task 1");
console.log("Task 2");
console.log("Task 3");
// Output: Task 1, Task 2, Task 3 (in order)

What Does Single-Threaded Mean?

Single-threaded means JavaScript has only one main thread (also called the main execution thread) that executes your code. This thread can only process one operation at a time.

Single-Threaded Example:

function heavyTask() {
    console.log("Heavy task started");
    // Simulate a time-consuming operation
    for (let i = 0; i < 1000000000; i++) {
        // Some computation
    }
    console.log("Heavy task completed");
}

console.log("Before heavy task");
heavyTask();
console.log("After heavy task");

// Output:
// Before heavy task
// Heavy task started
// Heavy task completed
// After heavy task

Notice how everything executes one after another. The heavy task blocks everything else until it completes.

Synchronous Operations in JavaScript

Synchronous means tasks execute one by one, in order, and each task must complete before the next one starts.

Synchronous Example:

console.log("Step 1");
console.log("Step 2");
console.log("Step 3");

// Output:
// Step 1
// Step 2
// Step 3

Each console.log waits for the previous one to finish before executing.

Real-world Synchronous Example:

function calculateSum(a, b) {
    console.log("Calculating sum...");
    return a + b;
}

function displayResult(result) {
    console.log("Result:", result);
}

console.log("Starting calculation");
let result = calculateSum(5, 10);
displayResult(result);
console.log("Calculation complete");

// Output:
// Starting calculation
// Calculating sum...
// Result: 15
// Calculation complete

The Puzzle: How Can Single-Threaded JavaScript Handle Asynchronous Operations?

Here's where it gets interesting. JavaScript can handle asynchronous operations despite being single-threaded. But how?

Asynchronous Example:

console.log("Start");

setTimeout(() => {
    console.log("This runs after 2 seconds");
}, 2000);

console.log("End");

// Output:
// Start
// End
// This runs after 2 seconds (after 2 seconds)

Notice how "End" prints before the setTimeout callback, even though setTimeout was called first!

The Secret: Event Loop and Browser APIs

JavaScript achieves asynchronous behavior through:

Event Loop - Manages the execution of code
Web APIs - Browser-provided APIs (setTimeout, fetch, DOM events)
Callback Queue - Stores completed async operations

How It Works:

console.log("1. First");

setTimeout(() => {
    console.log("3. Timeout callback");
}, 0);

console.log("2. Second");

// Output:
// 1. First
// 2. Second
// 3. Timeout callback

What happens:

console.log("1. First") executes immediately
setTimeout is handed off to Web API (browser handles the timer)
console.log("2. Second") executes immediately
When timer completes, callback goes to callback queue
Event loop puts callback on call stack when stack is empty

Real-World Asynchronous Examples

Fetching Data:

console.log("Starting data fetch");

fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => {
        console.log("Data received:", data);
    });

console.log("Fetch request sent");

// Output:
// Starting data fetch
// Fetch request sent
// Data received: {...} (when response arrives)

Multiple Async Operations:

console.log("Start");

setTimeout(() => console.log("Timeout 1"), 100);
setTimeout(() => console.log("Timeout 2"), 50);

Promise.resolve().then(() => console.log("Promise"));

console.log("End");

// Output:
// Start
// End
// Promise
// Timeout 2
// Timeout 1

Key Takeaways

JavaScript is single-threaded - Only one main thread executes your code
Synchronous operations block the thread until completion
Asynchronous operations use Web APIs and the event loop to avoid blocking
The main thread handles synchronous code and manages async callbacks
True parallelism requires Web Workers (separate threads)

Common Misconception

❌ Wrong: "JavaScript runs multiple operations simultaneously"
✅ Correct: "JavaScript delegates async operations to browser APIs and processes their results when ready"

The main thread itself doesn't run multiple operations at once - it cleverly manages them through the event loop system.

Understanding this concept is fundamental to writing efficient JavaScript code and avoiding common pitfalls like blocking the main thread with heavy synchronous operations.

The 150-Day Promise That Changed Everything

dravid p a — Mon, 14 Jul 2025 19:46:44 +0000

Hey, I'm Dravid. 20 years old. Newbie dev.

But here's the thing—I just did something that seemed impossible.

I gave up sugar for 150 days straight.

Yeah, you read that right. No candy, no sodas, no "just one bite" of cake at birthday parties. 150 days of saying no when everyone else said yes.

Why am I telling you this? Because if I can resist a chocolate bar calling my name at 2 AM for 150 days, I can definitely show up here every single day to share what I'm learning in code.

Here's my deal with you:

The dev world is flooded with creators. I get it. Another 20-year-old talking about JavaScript? Really?

But here's what makes me different—I don't just talk about consistency. I prove it. That sugar challenge wasn't just about health. It was about building the mental muscle to stick to commitments when no one's watching.

So here's what we're building together:

Raw, unfiltered learning journey (mistakes included)
1% better every day, no matter what
Real projects, real struggles, real breakthroughs
A community where newbies aren't just welcomed—we're celebrated

I'm not promising to be the smartest dev you follow. But I'm promising to be the most consistent one.

Ready to grow together?

Hit follow if you want to see what happens when someone who conquered 150 days without sugar decides to conquer code.

Let's make small stories into big victories. 🚀

Day 1 of sharing starts now.

DEV Community: dravid p a

Understanding Why `main` and `dev` Diverged

Scenario

What Happened?

Initial State

Changes Added to Main

Changes Added to Dev

Why git pull main Did Not Work

Correct Way to Update Dev

What Does git fetch Do?

What Does git merge origin/main Do?

If Merge Conflicts Occur

Push Updated Dev

Create Pull Request

Alternative Workflow

Simple Mental Model

Safe Workflow Summary

A Discord Group Accessed a Restricted AI That Finds Zero-Day Bugs -Here’s How It Happened

🧠 What actually happened?

⚠️ Why this is a BIG deal

🤯 The most important insight

🌍 Who should care?

🧩 Current status

⚡ Final thought

JavaScript: Single-Threaded but Asynchronous - How Does It Work?

What is a Thread?

What Does Single-Threaded Mean?

Single-Threaded Example:

Synchronous Operations in JavaScript

Synchronous Example:

Real-world Synchronous Example:

The Puzzle: How Can Single-Threaded JavaScript Handle Asynchronous Operations?

Asynchronous Example:

The Secret: Event Loop and Browser APIs

How It Works:

Real-World Asynchronous Examples

Fetching Data:

Multiple Async Operations:

Key Takeaways

Common Misconception

The 150-Day Promise That Changed Everything

Why `git pull main` Did Not Work

What Does `git fetch` Do?

What Does `git merge origin/main` Do?