DEV Community: Seif Ahmed

The Art of Binary Search

Seif Ahmed — Sun, 04 Oct 2026 14:05:02 +0000

Imagine you're looking up a word in a printed dictionary. You don't start at page one and read every word until you find it. Instead, you open the book to the middle. If your word comes earlier, you ignore the entire right half of the book. If it comes later, you discard the left half. You repeat this process until you land on the exact page.

This great strategy is called binary search. It's a fundamental algorithm used to find the position of a target value within a sorted array.

By cutting your search space in half with every single step, binary search achieves a logarithmic time complexity.

One Little Thing

For binary search to work, your data must be sorted. If the data is randomized, the algorithm won't work.

Two Ways to Define Boundaries

You've got to decide how to track your boundaries using two pointers: left and right. Devs generally choose between two standard approaches: the inclusive upper bound and the exclusive upper bound.

While both ways get the job done, they change your loop conditions and how you drop halves of the array.

Feature	Inclusive Upper Bound	Exclusive Upper Bound
Initial `right` value	`arr.length - 1`	`arr.length`
`while` loop condition	`left <= right`	`left < right`
Drop right formula	`right = mid - 1`	`right = mid`
Drop left formula	`left = mid + 1`	`left = mid + 1`

Approach 1: The Inclusive Upper Bound

In this traditional version, the right pointer targets the last valid index of the array. The search window includes both boundary pointers.

1. Setup and Loop Condition

You start by setting left = 0 and right = arr.length - 1. The loop repeats as long as left <= right. If the pointers cross (left > right), it means the target item isn't in the array. You should return a specific value (e.g. -1) to signal that nothing was found.

2. Shifting the Boundaries

After calculating mid = left + Math.floor((right - left) / 2), you compare arr[mid] to your target:

The Match: If arr[mid] == target, you return mid.
Drop the Right Side: If arr[mid] > target, the target is to the left. You update the boundary to right = mid - 1.
Drop the Left Side: If arr[mid] < target, the target is to the right. You update the boundary to left = mid + 1.

3. Simple Code Example (Don't use for all cases)

function binarySearchInclusive(arr, target) {
    let left = 0;
    let right = arr.length - 1; 

    while (left <= right) {
        const mid = left + Math.floor((right - left) / 2);

        if (arr[mid] === target) {
            return mid; 
        } else if (arr[mid] > target) {
            right = mid - 1; 
        } else {
            left = mid + 1;  
        }
    }

    return -1;
}

We calculate the mid index using left + Math.floor((right - left) / 2) because doing standard addition (left + right) in languages like Java or C++ can overflow the maximum 32-bit integer limit if you are searching through massive datasets. This formula keeps your code 100% safe across all environments.

Approach 2: The Exclusive Upper Bound

In this version, the right pointer represents the index just past the last element you want to search. The search window includes left but excludes right.

1. Setup and Loop Condition

You initialize left = 0 and set right = arr.length (the exact length of the array).

Because right is exclusive, a search space where left == right represents an empty range. Therefore, your loop condition changes to left < right. Once left equals right, the loop exits, signaling the item wasn't found.

2. Shifting the Boundaries

The main change is how right is treated. If arr[mid] > target, you drop the right half by setting right = mid. You don't use mid - 1 since the upper bound is exclusive.

3. Simple Code Example (Once again, don't use for all cases)

function binarySearchExclusive(arr, target) {
    let left = 0;
    let right = arr.length;

    while (left < right) {
        const mid = left + Math.floor((right - left) / 2);

        if (arr[mid] === target) {
            return mid; 
        } else if (arr[mid] > target) {
            right = mid; 
        } else {
            left = mid + 1; 
        }
    }

    return -1;
}

When to Use Each?

Inclusive Upper Bound: Use this version when you're looking for a single, exact match in a sorted array and want to return its index immediately.
Exclusive Upper Bound: Use this version when you want to find the first occurrence of a number in an array full of duplicates or you want to insert a new number while keeping the array sorted.

Why Binary Search is a Superpower

Imagine you've got an array of 1 million items.

Linear Search: Could take up to 1,000,000 steps if you're trying to find an item at the very end of the array.
Binary Search: Will find any item in roughly 20 steps.

Every time you use a drop formula, you wipe out thousands of unnecessary checks. It transforms a massive data search into a quick handful of simple choices.

Heap vs Stack Memory in C

Seif Ahmed — Sun, 27 Sep 2026 13:17:03 +0000

When I started learning C to expand my knowledge (I used to work with JavaScript and Node.js only), I asked myself: How to handle memory in C? I read a few articles on Google and Stack Overflow. And I found that memory in C is divided into two areas: the Stack and the Heap.

The Stack

Think of the Stack like a list where short lived variables, functions, and arguments live.

The compiler always manages the stack. When a function is called, its variables are pushed onto the stack. When the function finishes, the memory is cleared automatically.
It is very fast because the memory allocation is done in a sequential order.
The space on the stack is limited. If you allocate too much data (like a massive array), you will run into stack overflow errors.

void myFunction() {
    int age = 25; // Saved on the stack
}

The Heap

Think of the Heap like a massive pool of data. It's an unstructured block of memory designed for dynamic allocation.

You use functions like malloc() or calloc() to request space. That's why you should manually free the memory when you are done or you will cause a memory leak.
It's a bit slower than the stack because you need to look for and allocate the memory before adding data to it.
Its only limit is the physical machine you are using.

void myHeapFunction() {
    int *ptr = (int*)malloc(sizeof(int)); // Allocated on the heap
    *ptr = 25;

    // Don't forget this line btw
    free(ptr); 
}

Why Stack Overflow Happens

A stack overflow occurs because the stack has a memory limit. For example, if you've an infinite loop, these frames stack up without being cleared. They'll cross the boundary set by the OS and your program will crash to protect the rest of the system from corruption.

Why Memory Leaks Happen

Memory leaks occur in the heap because memory should be manually managed. When a program requests dynamic memory, the OS reserves a memory block for it and returns a pointer to it. The memory is freed when your program calls the free() function. If your program stops before this function is called, there is no pointer to this memory block and it becomes inaccessible. This memory is reserved until the application is closed. These little bugs eat RAM and the application usually stops responding until it's forced to stop.

Quick Comparison

Feature	The Stack	The Heap
Management	Managed by the compiler	Managed by the programmer
Lifetime	Short lived	Long lived (lasts until manually freed)
Size Limit	Limited and fixed	Limited by your machine hardware
Allocation Speed	Extremely fast	Slower

Learning this was really fun. I'm happy that I shared this with you guys.

🚀 I reached 1,001 views on DEV!

Seif Ahmed — Mon, 21 Sep 2026 19:03:39 +0000

I just did it! I looked at my DEV dashboard and noticed that my profile has reached 1,001 total views.

First, thanks to this amazing community. Whether you read a full article, clicked through from Google search, left a comment, or dropped a unicorn 🦄 or heart ❤️ reaction, your engagement means the world to me.

When I first started publishing, I wasn't sure if anyone would actually read what I had to say. Seeing that people have found their way to my articles 1,001 times is really motivating. Thanks again for being a part of my journey. Let's keep building, writing, and learning together! 🚀

What was your favorite milestone when you started content creation? Let me know in the comments below!

Refactoring Vlox's Theme Engine 🎨

Seif Ahmed — Tue, 01 Sep 2026 13:07:00 +0000

Most standard theme systems swap a single global class on the <body> element. My engine can handle many themes at once.

The Update:

In the past, themes were tracked by index. I noticed that reordering the array broke saved themes for existing users.

To fix this, I used unique keys for themes instead of indexes.

The Configuration:

Each unique theme contains an array of configuration objects. Every configuration object contains 4 keys:

class: (Required): The target CSS class name.
elements: (Required): Elements targeted immediately on page load.
postsElements: (Optional): Elements targeted ONLY after Vlox posts finish loading.
remove: (Optional): Specifies whether to add or remove the class.

The Logic:

The current theme is tracked in a variable called currentTheme. When a page reload happens, it reads the value from localStorage. If the value in the localStorage doesn't match any theme name, currentTheme value becomes "default" without updating the broken value in localStorage. I did this to prevent Vlox from breaking other apps that may use the same localStorage key while keeping my theme engine 100% working. Also, users won't be stuck on the invalid value. Once they choose a valid theme from Vlox, the localStorage value gets updated.

If you liked Vlox, please consider giving it a 🌟 on GitHub at https://github.com/Hfs2024/Vlox. It means the 🌎 to me!

You Wished for It. Here It Is. ❤️

Seif Ahmed — Thu, 27 Aug 2026 12:18:09 +0000

I know how tough it can be to build smooth, secure backend features, so I wanted to bring a little joy to your day. I made this polished gift redemption system as my little present to you!

How It Works:

1. Security & Validation

Authentication: The code checks if the user is logged-in.
ID Validation: It ensures the gift ID in the URL is a valid database ID.

2. Math Limits

The maximum character limit allowed is 4000 characters.
It calculates how close the user currently is to that limit.
It attempts to grant the user a +100 character boost, capping it if they are already near the 4000-character.
While the system may calculate the same inc value for concurrent requests, the atomic updateOne operation ensures that if applying both boosts exceeds the 4000-character limit, only the faster request succeeds.
The max redemption tries admins can set for gifts is 100. Once the max tries limit is reached, whether you set it to 6, 8 or 100, the gift will no longer be usable. After a day from the gift creation date, it will automatically delete itself under any condition to save space.

3. Transactions (All or Nothing)

The system starts a database transaction. This guarantees that both the gift update and the user update must succeed together. Otherwise, the entire operation rolls back.

The query looks for an active gift that the current logged-in user has not claimed yet. It increments the gift's usage count (usedCount), save the user's ID in the usedBy array so they cannot claim it again, and changes the status to "expired" if it just reached its max available uses.
Also, it adds the calculated character boost to the user's account.

One more thing: If the gift is invalid, expired or already redeemed by the logged-in user, the code aborts the transaction. Otherwise, it successfully returns a success: true response.

Hope you liked your 🎁!

I created my X account! 🐦

Seif Ahmed — Wed, 26 Aug 2026 06:27:25 +0000

Let's Connect (Follow for Follow! 🤝)

I just created my X (Twitter) account to document my journey, share open-source updates, and connect with other developers.

If you want to support me or just talk about tech, let's connect:

👉 Follow me on X:

Seif Ahmed (@seifahmedcoding) / X

Creator of Vlox — the ultimate social network! I also built NanoScript — a custom DOM library for easier web development!

x.com

I'm actively following back everyone from the DEV community who hooks up with me there. Drop your X handle or your latest side project in the comments below so I can check out what you are building too!

Refactoring the views system in my markdown previewer!

Seif Ahmed — Tue, 18 Aug 2026 12:30:45 +0000

In the past, link views in my markdown previewer were cached in Redis. After 10 seconds from a link open, all the views were flushed using a manual loop.

The old flow looked like this:

Loop through every key (ID).
Update its views separately via updateOne.
Move to the next until the loop ends.

Why This Is Wrong:

N+1 Problem: As the number of key operations grows, it runs many separate trips. Under very heavy traffic, the system can run out of resources and crash.
Duplicated Views: In this old flow, I never cleared the views, even after flushing them. This caused a duplicated view count.
No Validation: The system never checked if there were keys to update or not, running unnecessary empty operations.

The Fix:

Instead of running many separate updateOne operations, we group them into bulk operations using bulkWrite. This way, if we have 100 links viewed, we run 1 operation, unlike the 100 operation in the old system.

The New Flow:

Run hGetAll to get views.
Check if there is valid data to process. If not, skip this operation entirely.
Map the ID operations (Lightweight for niche apps like ours. I'm not trying to build something for billions, but a quick markdown previewer for devs like you).
Send the request to the database and update with bulkWrite.
If the request reaches the database and is acknowledged, delete the old views. This guarantees that if the server crashes midway, the data is not lost

Note: I added ordered: false because, by default, if one operation fails, the remaining operations are not executed and previous ones are not rolled back.

Liked Markdown Previewer? Give it a ⭐ at https://github.com/Hfs2024/Markdown-Previewer!

[Boost]

Seif Ahmed — Tue, 11 Aug 2026 12:04:19 +0000

Seif Ahmed

Aug 4

I made a gift for you: A clean, lightweight Markdown Previewer

#showdev #github #opensource #webdev

1 min read

[Boost]

Seif Ahmed — Mon, 10 Aug 2026 18:02:14 +0000

Seif Ahmed

Aug 4

I made a gift for you: A clean, lightweight Markdown Previewer

#showdev #github #opensource #webdev

1 min read

Building a password-protected link sharing workflow

Seif Ahmed — Sun, 09 Aug 2026 14:01:05 +0000

Ever wondered how to build a clean, secure system for sharing user content via unique links? It gets interesting when you have to separate public access from password-protected private shares.

Here is a breakdown of how my markdown previewer handles this:

URL Activation: A user opens the link http://localhost:3000/?id=POST_ID.
ID Extraction: The frontend parses the URL and extracts the ID using URLSearchParams.
Request Initiation: If an ID is present, the frontend requests data from /api/v1/get/save-from-link/:id.
Backend Verification: The backend checks if the ID exists in the database.
Public Access: If the link is public, the backend returns the content (link.for.content).
Private Access: If the link is private, the backend responds with a success signal and need_password: true without sending any content.
Frontend Evaluation: The frontend checks the need_password flag.
Content Display: If false, it renders the public content.
Password Prompt: If true, a popup prompts the user to enter a password.
Rate Limiting: Users get 10 password attempts per 7 minutes across all private saves globally.
Password Validation: The frontend sends the ID and password to /api/v1/validate-save-password/:id.
Security Match: The backend queries the ID ensuring status: "private", then verifies the password using await bcrypt.compare(password, link.password).

Liked my Markdown Previewer? Please give it a ⭐ on GitHub at https://github.com/Hfs2024/Markdown-Previewer!

Why I built an ultra-light social network

Seif Ahmed — Fri, 07 Aug 2026 19:57:15 +0000

A thousand packages in the tree,
A heavy runtime, rarely free.
You spin up React just to write a post,
While memory leaks consume your host.

So I carved a space away from the noise,
To bring back simplicity, speed, and choice.

A sanctuary for you and your hobbies

No Virtual DOM to drain your pace,
Ghost States ensures you never lose your trace,
Pure NanoScript flowing clean and light,
A private network built just right.

The Bloated Way	The Vlox Way
React (hundreds of MBs)	NanoScript (a few KBs)
Complex state boilerplate	Automatic Ghost State saving
Sluggish edge environment loads	Instant response

Take a breath, leave the bloat behind, and see how fast the web can be when it isn't weighed down.

🚀 Live Demo: https://vlox.containers.snapdeploy.app/ or https://vlox.bonto.run/
⚡ Vlox Codebase: https://github.com/Hfs2024/Vlox

I made a gift for you: A clean, lightweight Markdown Previewer

Seif Ahmed — Tue, 04 Aug 2026 16:48:30 +0000

Demo

Your browser does not support the video tag.

You seem so tired, deep in thought,
With every question and answer you brought.
So as a gift to ease your view,
I built a markdown previewer for you.

A Little Rest for Your Code

Crisp headers shine so bright and clear,
Soft lists and tables now appear,
No walls of text to strain your mind,
Just tidy code left far behind.
Then shouldn't you come here and never hide?

Before	After
Bad design	Clean design
Weary Look	Refreshed view

So take a break and watch it glow,
And let your mind rest and slow.

Give it a try: https://github.com/Hfs2024/Markdown-Previewer.