Big O Notation

A concept that serves as both a negotiation tool and a practical decision-making framework, on efficiency of an algorithm that suits the needs of current problem. Big O just tells how slower my program is going to be as the input size increases.

So technically, It doesn't dictate which algorithm you should use; instead, it provides clarity for understanding how different choices impact performance when your data grows. In essence, it simply says, "It is what it is :P"

Let's understand with an Analogy:
I’m not a fan of explaining technical concepts using another math or tech concepts right off the bat to self. Over the years, I’ve realized that problem-solving in technology often mirrors the decision-making we do in our everyday lives. The underlying principles are the same; it’s just that in tech, the language are well worded to be used and put across. The micro-decisions we make daily are very much similar to the decisions we make when solving technical problems.

While thinking about Big O, a chess scene popped into my mind. It may not be the perfect analogy, but it serves the purpose of illustrating the concept well.

Let’s set the stage: Ana and Bana are competing in an intense chess match. Both are sharp-minded, calculating every move carefully. In the game, Ana starts running calculations in her mind. “If I move this piece here, and then that piece there, I can achieve a favorable position. But if Bana responds by moving that piece, I’ll need a counter-strategy to regain control.” And so on, and so forth. Through this process, she develops what she believes is an efficient strategy to secure a win.

Now, let's introduce a constraint: a 30-minute time limit for the entire game.
Suddenly, efficiency takes on an entirely new meaning. Time isn’t just a luxury anymore; it’s the essence of the game. Ana’s previously calculated strategies might still be sound, but they were designed with the luxury of an unlimited time frame. So is it really efficient?
She comes up with bunch of strategies.
Example:

• Strategy 1 takes 18 minutes
• Strategy 2 requires the full 30 minutes
• Strategy 3 needs 26 minutes
  Each strategy leads to a win, but they all have different time costs. This mirrors how we evaluate algorithms:
  This is where Big O steps in—not necessarily to tell Ana which strategy to choose, but to help her understand the trade-offs between them

In the chess scenario:

• Ana isn't just calculating a fixed number of moves (which would be O(1))
• She's evaluating possible move sequences, creating a decision tree
• As the number of potential future positions grows, the complexity increases
• This is similar to how algorithms scale with input size
• The time constraint forces her to consider practical efficiency, not just theoretical effectiveness

In the beginning of my post I mentioned it's a way of negotiating- by that this is what I meant

Big O as a Negotiation Tool

When developing software, Big O helps us negotiate between competing constraints:

1. Time efficiency (how fast the algorithm runs)
2. Space efficiency (how much memory it requires)
3. Implementation complexity (how difficult it is to code and maintain)
4. Actual performance on expected input sizes (not just theoretical scaling)

Sometimes an O(n²) algorithm is perfectly reasonable for small datasets. Other times, you absolutely need an O(n log n) solution because your data will grow exponentially.

The Practical Value

In practical software development, Big O analysis helps us :

• Predict scaling issues before they occur
• Choose appropriate data structures and algorithms based on expected use cases based on negotiating points^
• Communicate performance characteristics to team members
• Make informed trade-offs between different solution approaches

And guess what during my college I purely saw Big O as an academic exercise as it wont buz into my head, but over the years now when I have worked on extensive products I often thought about in these similar lines, so having this concept clarity is good- think of it as a practical decision-making framework that helps understand the performance implications of code as data grows.

Big O doesn't tell what to do—it empowers you to make better decisions based on your specific constraints and requirements.

And now take look at this video for Big O with a DS example: