DEV Community: Zeyad Eissa

Kadane's Algorithm

Zeyad Eissa — Fri, 26 Sep 2025 18:55:26 +0000

Kadane's Algorithm – Efficient Maximum Subarray Sum
The Problem

Imagine you're playing a game where you score positive or negative points each round.
You want to find the maximum total score you can get by choosing a sequence of consecutive rounds.

This is known as the:

Maximum Subarray Problem

Naive (Brute Force) Solution

You could solve it by checking all possible subarrays and summing each one.
Example:

[2, -3, 6]

All possible consecutive subarrays:

Subarray Sum
[2] 2
[2, -3] -1
[2, -3, 6] 5
[-3] -3
[-3, 6] 3
[6] 6 ✅

The maximum sum is 6.

But this method becomes very slow for long arrays → O(n²) time complexity.

Kadane’s Algorithm (Efficient O(n) Solution)

Kadane’s Algorithm solves this problem in linear time → O(n)
It's based on Dynamic Programming, but it’s extremely space-efficient (uses only two variables).

Key Concepts

We use two variables:

Variable Purpose
currentSum The running sum of the current subarray (candidate for max subarray)
maxSum The best (maximum) sum found so far

We iterate through the array once, updating these two values at each step.

Algorithm Logic

At each item x in the array:

Add x to currentSum → means we’re trying to extend the current subarray.

If currentSum > maxSum, update maxSum.

If currentSum < 0, reset currentSum to 0 → we start fresh, because a negative sum will hurt any future subarray.

JavaScript Implementation

Let’s walk through the array:

const arr = [2, -1, 3, -4, 5, -2, 2];
Index Value currentSum Before currentSum After maxSum
0 2 0 2 2
1 -1 2 1 2
2 3 1 4 4 ✅
3 -4 4 0 (reset) 4
4 5 0 5 5 ✅
5 -2 5 3 5
6 2 3 5 5

Final result: maxSum = 5

Special Case: All Negative Numbers

If the array has only negative numbers, Kadane’s algorithm still works because we initialize:

let maxSum = -Infinity;

So it will still return the maximum negative value instead of returning 0.

Summary

Kadane’s algorithm solves the Maximum Subarray Problem in O(n) time and O(1) space.

It uses only two variables: currentSum and maxSum.

You reset currentSum to 0 when it becomes negative, because any negative prefix will reduce your future total.

Kadane’s Algorithm is a clean, fast, and optimal way to find the largest sum of a contiguous subarray.

Caching in Node.js with TypeScript using globalThis and declare global

Zeyad Eissa — Fri, 26 Sep 2025 17:07:24 +0000

When working in a Node.js environment, especially with TypeScript, you might come across situations where you need a simple caching mechanism — something lightweight to store a variable that stays alive as long as the server is running.

One of the most efficient and straightforward ways to achieve this is by using globalThis and declare global.

Let me walk you through how and why I used this approach in a real-world scenario, and break down the concepts from start to finish.

The Problem I Faced
In one of my projects, I was managing bookings for workshops. Each booking record included a vehicle_id, which pointed to a vehicle stored in another system.

We had a third-party system that needed to fetch booking data along with vehicle details in the same API call.

To support this, I created a hook in Directus that runs before every bookings fetch operation. This hook was responsible for:

Detecting if the vehicle_id exists.

Fetching the full vehicle data from the external system.

Attaching the vehicle object to the booking result.

The Real Challenge: Avoiding Duplicate API Calls
I didn’t want to fetch the same vehicle data multiple times, especially since vehicle data doesn't change frequently. That would waste time and network resources.

So I needed a simple caching layer to store the vehicle data after the first fetch, and reuse it for future requests — as long as the server is still running.

What is globalThis?
In JavaScript (and TypeScript), globalThis is an object that gives you access to the global scope, no matter the environment (Node.js, browser, etc).

That means any variable you attach to globalThis will be accessible from anywhere in your code, and will live as long as the server process is running.

Example:

globalThis.myAppName = "DriveMotive"; console.log(globalThis.myAppName); // Output: DriveMotive
Using globalThis with TypeScript
In a TypeScript project, if you try to write:

globalThis.__vehicleCache = new Map();
You’ll get a TypeScript error:

❌ Property '__vehicleCache' does not exist on type 'typeof globalThis'.

That’s because TypeScript is type-safe and doesn’t know about this property unless you explicitly tell it.

How to Declare a Global Variable in TypeScript
Step 1: Let TypeScript know this is a module
At the top of the file (usually types.d.ts), add:

export {}; // This makes the file a module
Step 2: Declare the global variable

declare global { var __vehicleCache: Map | undefined; }
This tells TypeScript:

"Hey, there is a global variable called __vehicleCache, and it's either a Map or undefined."

Step 3: Initialize the Cache
In your actual logic, you need to initialize the cache if it's not already created:

const vehicleCache = (globalThis.__vehicleCache ??= new Map());
This single line does three things:

Checks if __vehicleCache already exists in globalThis

If yes, assigns it to vehicleCache

If not, creates a new Map() and assigns it

I Hope This Post was Helpful, See you in the Next One.

JavaScript Quick Tips

Zeyad Eissa — Mon, 22 Sep 2025 14:18:51 +0000

Var vs Let and Const

Consider the following code:
function sayHi() { console.log(name); console.log(age); var name = "Alex"; let age = 24; }
If you run this function, the output will be:

Consider the following code:

function sayHi() { console.log(name); console.log(age); var name = "Alex"; let age = 24; }

If you run this function, the output will be:
undefined
ReferenceError
Why does this happen?

Variables declared with var are hoisted to the top of their scope during the compilation phase.
Hoisting means JavaScript creates a memory space for the variable before the code executes, but it does not assign a value yet. Instead, the variable is initialized with undefined.
That’s why when we log name before its assignment, we see undefined instead of an error.

Variables declared with let and const are also hoisted, but the key difference is that they are not initialized automatically.
They remain in a special state called the Temporal Dead Zone (TDZ) from the start of their scope until the line where they are actually assigned a value.
If you try to access them in this zone (before initialization), JavaScript throws a ReferenceError.

In short:

var → hoisted and initialized with undefined immediately.

let & const → hoisted but stay uninitialized (TDZ) until the code execution reaches their declaration.
Arrow Functions vs Regular Functions in JavaScript

Let’s look at this code example:

const square = { sideOfSquare: 10, // Regular function area() { return this.sideOfSquare * this.sideOfSquare; }, // Arrow function perimeter: () => this.sideOfSquare * 4 }; console.log(square.area()); // 100 console.log(square.perimeter()); // NaN
Why does this happen?

Regular function (area)

When you use a regular function inside an object, this refers to the object itself (square).

That means this.sideOfSquare correctly points to 10, so the result of area() is 100.

Arrow function (perimeter)

Arrow functions don’t have their own this.

Instead, they use the this value from the outer scope (the place where the function was created).

In this case, the arrow function is created inside the object literal, but the this it captures is not the object itself — it’s usually the global scope (window in browsers or undefined in strict mode).

Since there’s no sideOfSquare in the global scope, the result is NaN.

In Short:

Use regular functions when you need this to refer to the object.
Use arrow functions when you want to preserve the this from the outer scope (for example, inside callbacks).
Dot notation vs Bracket notation

Consider this code:
const bird = { size: "small" } const mouse = { name: "Mickey", small: true };
We can perform something like this:
mouse[bird.size] → because bird.size gives us "small", which will be evaluated as mouse["small"] = true. So this is valid.

Another option is:
mouse[bird["size"]] → because the inner operation also gives "small", leading to mouse["small"].

What is wrong is trying:
mouse.bird.size → here mouse.bird is undefined, so accessing .size will throw an error (undefined.size).

In short:

Dot notation: The key must literally exist as a property.

Bracket notation: The key can be a variable or expression that resolves to a property name.