Forem: Devmancer

The big-o-notation

Devmancer — Sat, 21 Feb 2026 00:39:32 +0000

When we talk about algorithms, we often describe them using asymptotic notation, and one of the most common types is Big-O notation.

Big-O represents the worst-case time complexity of an algorithm.

But what does that really mean?

Think of it like this:

Big-O asks your code:
“As more customers come in, how crazy does the work become?”

In other words, Big-O measures how your code behaves as the input size gets bigger.

What is “n”?

n represents the size of the input.

For example:

If you have an array with 5 numbers → n = 5

If you have 1000 numbers → n = 1000

Big-O is simply asking:

If n increases, how much do the number of steps increase?

O(1) —> Constant Time
const array = [1, 2, 3, 4];
console.log(array[0]);

This is O(1) —> constant time.

Why?

Because it doesn’t matter if the array has:

4 elements

1,000 elements

1,000,000 elements

Accessing array[0] always takes one step.

The work does not grow as n grows.

O(n) —> Linear Time
for (let i = 0; i < arr.length; i++) {
console.log(arr[i]);
}

This is O(n) —> linear time.

Why?

Because the loop runs once for every element.

If there are 5 elements → the loop runs 5 times

If there are 100 elements → the loop runs 100 times

The number of operations grows at the same rate as the input size.

If n doubles, the work doubles.

O(n²) —> Quadratic Time
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
console.log(i, j);
}
}

This is O(n²) —> quadratic time.

Why?

The outer loop runs n times.

For each outer loop, the inner loop also runs n times.

So total operations = n × n = n².

If:

n = 5 → 5 × 5 = 25 operations

n = 100 → 100 × 100 = 10,000 operations

Now the work grows much faster than the input.

If n doubles, the work increases four times.

Important Rule About Big-O

Big-O cares about growth, not exact numbers.

If an algorithm takes:

2n² + 10n + 100

We still write it as:

O(n²)

Why?

Because when n becomes very large, the n² term dominates everything else.

Big-O keeps only the fastest-growing term.

Quick Summary

O(1) → stays the same no matter what

O(n) → grows at the same rate as the input

O(n²) → grows much faster than the input

Big-O measures growth as input increases

We ignore constants and smaller terms

my understanding of crud applications,controllers, and middlewares.

Devmancer — Fri, 21 Nov 2025 18:26:46 +0000

Okay, before we start - quick disclaimer: I am in no way a professional. I'm just typing this stuff here because I'm too lazy to write notes in my book.

Now, let's begin!

To me, CRUD applications feel like the backbone of many systems. They help us Create, Read, Update, and Delete data - you know, the stuff everyone knows. But during my adventure in the world of CRUD, I seemed to have found another layer, a deeper mystery so to speak.

Long story short, I basically had to understand the difference between middleware and controllers. To be honest, I don't really know where to draw the line completely, but my knowledge has evolved since last time - I'll tell you that!

I used to think that anything with app.use() was middleware (not my proudest moment, to be honest - don't judge! Also, if you're planning to, please notice the #newbie hashtag - thanks!).

My Middleware vs Controller Revelation
Now I've figured out it's much more intriguing than that. The main distinction I found separating middleware and controllers is that controllers handle the final response, while middleware uses next() to pass control to the next function.

Code exmaple:

just think of middlewares as waiters:
they,

Grinds the beans

Steams the milk

Checks if you paid

Then passes it along "Next!"

then controllers they are the ones who:

Puts everything together

Adds the final touches

Hands you the finished drink "Here's your coffee!"

(beautiful illustration analogy btw )

The Order Matters Saga
Oh, and lest I forget - did you know that the order of middleware actually matters? Funny story: I actually found that out while setting up routes for my operations, and I put updateUser before validateUser. Thank god for ChatGPT, am I right guys?

Anyway, let's not glaze Sam right now. I'm quite happy I've gained this knowledge!

Follow me to see my next blog on Swagger documentation!

Why parametized functions make your code cleaner

Devmancer — Thu, 04 Sep 2025 20:33:01 +0000

When you’re new to JavaScript, it’s tempting to write logic directly inside event listeners. It works until your code grows. Soon you’re repeating yourself, fixing bugs in multiple places, and struggling to keep everything in sync. Thats why parametized functions is important.

Take this example of a calculator app. Each button (+, -, ×, /) needs to:

Save the first number.
Store the operator.
Clear the display.

Without parameters, you end up repeating logic:

Instead of repeating the same steps, wrap them into one reusable function with a parameter:

this improves usability because:

DRY Principle (Don’t Repeat Yourself): One function handles all operators.

Easier Maintenance: Change logic once, and every operator updates.

Scalable: Adding more operators (like % or √) is just one line.

Readable: The intent is clear “set operator to X"

I do think parametized functions make your code clean and reusable