Check the live session here: Watch on YouTube

🎙️ The "Pre-Game" Struggle: Audio is Hard

Before hitting a single line of C++, I spent the first 10 minutes fighting OBS Studio. If your mic gain is too low, nobody listens. If it’s too high, you’re clipping and blowing out eardrums.

• The Fix: Added a Gain Filter in OBS, settling between 13 dB and 19 dB.
• Pro-tip: Use Noise Suppression (RNNoise) if you’re coding in a room with a loud fan or Indian street traffic.

🧠 Algorithmic Evolution: The Sliding Window

We tackled the Maximum Average Subarray problem. The naive way to find the average of elements in an array of size is . That's garbage.

The "Sliding Window" Optimization

Instead of re-summing elements every time, you just:

1. Subtract the element leaving the window.
2. Add the element entering the window.

Performance Hack: Don’t calculate the average inside the loop. Division is expensive for a CPU. Compare the sums instead, and do a single division at the very end.

// Optimized Logic
for (int i = k; i < nums.size(); ++i) {
    currentSum += nums[i] - nums[i - k];
    maxSum = std::max(maxSum, currentSum);
}
return (double)maxSum / k; // Single division = Win

🏎️ C++ Micro-Optimizations for HFT

When building a Trading Terminal (which I’ve renamed to Hir Trader to avoid trademark drama), every clock cycle is a liability.

1. Prefix vs. Postfix

Stop using i++. Use ++i.

• i++ (Postfix) creates a temporary copy of the object before incrementing.
• ++i (Prefix) increments in place. In a loop running millions of times, those temporary objects add up to a performance tax you don't want to pay.

2. False Sharing & Cache Alignment

In multithreaded trading engines, two threads can fight over the same Cache Line even if they are touching different variables.

• The Solution: Use alignas(64) to ensure your atomic variables stay on their own cache lines. This prevents "False Sharing," which can destroy your throughput faster than a bad algorithm.

📅 The Workflow: Discipline > Motivation

I’m keeping a strict work log and using WinGet for package management to keep the environment clean. Most of the heavy lifting is in C++ and CMake, with a focus on benchmarking the matching engine to handle 100+ orders with sub-millisecond latency.

Cultural Note

While the West worries about Friday the 13th, we’re out here celebrating Sankranti and Ekadashi. It's a good reminder that perspective changes everything—whether in life or in code.

What's Next?

The benchmark results for the matching engine are coming next. I’ll be pushing the concurrency-safe structures to GitHub soon.

#CPlusPlus #HFT #CodingLife #SoftwareEngineering #Optimization #SlidingWindow

In a recent deep-dive session, I explored the intersection of technical problem-solving—specifically tackling the Triplet Sum to Zero problem—and the broader challenges of being a creator and developer in India today.

You can watch the full journey here: Watch on YouTube

🛠 The Technical Struggle: From Fedora to Windows

Every Linux enthusiast knows the struggle: the power of customization vs. the need for stability. My session began with a deep dive into Fedora, ZSH, and GCC setups. However, when you’re trying to record and stream, tools like OBS Studio can be temperamental on Linux distributions.

Ultimately, the need for a seamless workflow led to a shift back to Windows to ensure performance optimizations and profile imports went smoothly. We also explored setting up VS Codium (the telemetry-free alternative to VS Code) to keep the development environment lean and privacy-focused.

🧠 Algorithmic Deep Dive: Solving "Triplet Sum to Zero"

The core of the technical segment focused on a classic competitive programming challenge: finding all unique triplets in an array that sum up to zero.

The Evolution of the Solution:

1. The Brute Force Approach (): Initially, using three nested loops is the most intuitive way to find triplets. However, this quickly leads to "Time Limit Exceeded" (TLE) errors on most platforms because the complexity grows cubically with the input size.
2. The Optimization (): By sorting the array first (), we unlock the ability to use the Two-Pointer Technique.
3. Refining with Hash Sets: To handle the "unique" constraint and avoid duplicate triplets, we implemented Hash Sets and clever pointer increments. This reduced the runtime significantly, moving the solution from "rejected" to "accepted."

Key Takeaways for Your Next Interview:

• Sort First: Sorting is often the "cheat code" for array-based sum problems.
• Two-Pointers: When you have a target sum, two pointers (start and end) moving toward each other can turn an problem into .
• Space-Time Tradeoff: Using a Hash Set costs memory but saves precious execution time.

🇮🇳 Beyond the Code: The Reality of Talent in India

While solving for is satisfying, the video also touches on the "systemic complexity" of being a student and professional in India. We had a candid discussion about:

• The Talent Drain: Why many of India's brightest minds feel compelled to move abroad due to a lack of local recognition and systemic barriers.
• Education Costs: The disparity between high-cost private colleges and the extreme competition of government institutions.
• Quality of Life: From air quality concerns to food safety issues (like E.coli levels in milk), the "environment" a developer lives in is just as important as the IDE they use.

Despite these frustrations, there is a recurring theme of hope and faith. Invoking the spirit of Shri Krishna, the discussion reflects a desire for divine intervention and a better future for the next generation of Indian builders.

📚 Tools & Concepts Mentioned

• GCC & ZSH: The backbone of the terminal experience.
• Sliding Window: Briefly discussed for subarray problems.
• Segment Trees: A look into more advanced data structures for range queries.
• OBS Studio: The go-to for recording, despite its Linux quirks.

Final Thoughts

Being a developer is more than just writing syntax; it's about navigating the tools we use and the world we live in. Whether you're debugging a C++ triplet sum or debugging the society around you, persistence is the only way forward.

Check out the full video for the code walkthrough and the commentary: 👉 Evolution of an Algorithm & Life Reflections

#Programming #Algorithms #WebDev #India #Linux #OpenSource #Career #CodingLife

The Pursuit of Discipline

I’ll be honest: today was a rough day and my mood was quite off. I faced setbacks with two Online Assessments (OAs)—one for Milliman that didn't go well and another for Salesforce that featured complex DP and Graph questions. However, in HFT, discipline means showing up and documenting the grind even when things aren't going your way.

The Internship Grind

Despite the personal setbacks, I maintained my professional momentum. I put in over 3 hours of work on my remote internship, successfully completing three TypeScript tasks and getting my Pull Request merged.

Technical Deep Dive: Two Sum II (Sorted Array)

Today's focus was on LeetCode 167, which is a more constrained version of the classic Two Sum problem.

1. The Problem Statement

Given a 1-indexed array of integers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number.

• Brute Force (O(N²)): A nested loop approach checking every possible pair—too slow for high-performance requirements.
• HFT Optimized (O(N)): Since the array is already sorted, we can use a Two-Pointer approach to find the target in a single pass.

2. The Logic

• Initialize Pointers: Place one pointer (left) at the beginning of the array and another (right) at the end.
• Sum Comparison: If the current sum is greater than the target, decrement the right pointer to decrease the sum. If the sum is less than the target, increment the left pointer.
• Memory Optimization: I initially used long long for the sum but realized a standard int was sufficient given the input constraints, avoiding unnecessary memory overhead.

3. Results

• Time Complexity: O(N)
• Space Complexity: O(1)
• Index Adjustment: Because the problem uses 1-based indexing, I adjusted the final indices by adding 1 to the result pointers.

Current Status: 5/90 Days Complete

Today was a "reality check" day, but the 90-day grind doesn't stop for bad moods or failed OAs. I'll be back tomorrow to pick up the pace, likely moving toward Three Sum problems.

#HFT #CPP #TwoPointers #90DayChallenge #MAIT #TypeScript #Discipline

The Pursuit of Discipline

Day 4 is about refining the "Signal." In high-frequency trading, every nanosecond counts, and today I focused on how both our algorithms and our choice of data structure management impact latency. I’m continuing to use my digital tablet setup to practice "whiteboarding" my thought process—it’s a raw way to ensure I can communicate complex logic clearly under pressure.

The "Rubber Duck" Breakthrough

As always, Mr. Pengu was there to "interview" me as I worked through the logic. I spent some time troubleshooting my recording setup to ensure a steady frame rate for the live coding segments.

Technical Deep Dive: Search in Rotated Sorted Array

I tackled the Search in Rotated Sorted Array problem (LeetCode 33).

1. The Problem Statement

Given an integer array nums sorted in ascending order with distinct values, which is then possibly rotated at an unknown pivot index k, find the index of a target value.

• Brute Force (O(N)): A linear search checking every element.
• HFT Optimized (O(log N)): Even in a rotated array, one half (either left or right of the midpoint) is always sorted. By identifying the sorted half and checking if the target lies within its range, we maintain binary search efficiency.

2. The Logic

• We calculate the midpoint using the overflow-safe formula: low + (high - low) / 2.
• Identify which half is sorted by comparing nums[low] with nums[mid].
• If the left half is sorted, check if the target is within that range to decide where to move the pointers.
• Repeat the logic for the right half if the left isn't sorted.

3. The HFT "Gotcha": `std::vector::reserve`

I spent about 30 minutes analyzing the hidden costs of std::vector.

• The Problem: Dynamic resizing (vector doubling) is expensive because it requires reallocating memory and copying all existing elements.
• The Solution: Use v.reserve(n) to allocate memory upfront. This prevents multiple reallocations and unnecessary data movement during push_back operations, which is critical for low-latency systems.

Current Status: 4/90 Days Complete

I'm starting to see the connections between basic DSA and hardware-level performance. Mastering these reallocations and boundary conditions is the only way to handle the high-pressure questions asked by firms like Graviton or Tower Research.

#HFT #CPP #BinarySearch #90DayChallenge #MAIT #FedoraLinux

The Pursuit of Discipline

I’ll be honest: I struggled with procrastination yesterday. I realized my previous 40-minute videos were too long to be sustainable logs, so I'm shifting to more focused updates. In HFT, efficiency is everything—not just in the code, but in how you manage your time.

The "Tablet Setup" Breakthrough

To become better at technical interviews, I needed a way to draw logic in real-time. I spent a good portion of today setting up scrcpy on my Fedora Linux system to mirror my Motorola tablet.

• The Engineer's Choice: I opted for a USB cable connection over Wi-Fi to ensure the lowest possible latency and best performance while sketching.

• The "Rubber Duck": As always, Mr. Pengu was there to "interview" me as I worked through the setup and the code.

Technical Deep Dive: Floor in a Sorted Array

While I’m logging this today (February 8th), this progress is for yesterday (February 7th). I tackled the Floor in a Sorted Array problem.

1. The Problem Statement

Given a sorted array and an integer X, find the index of the largest element in the array that is less than or equal to X.

• Brute Force (O(N)): A simple linear search where you check every element until you find one larger than X.

• HFT Optimized (O(log N)): Since the array is sorted, we must use Binary Search.

2. The Logic

• We calculate the midpoint using left + (right - left) / 2 to prevent integer overflow—a small but critical detail for high-performance systems.

• If array[mid] <= X, we store this index as a potential answer and move to the right half (left = mid + 1) to see if a larger "floor" exists.

• If array[mid] > X, we move to the left half (right = mid - 1).

3. Results

• Time Complexity: O(log N)

• Space Complexity: O(1)

• Performance: The solution passed all cases with a runtime of 0.454s.

Current Status: 3/90 Days Complete

I know I've been a bit slow, but I'm picking up the pace. Mastering these fundamental boundary conditions is the only way to handle the high-pressure questions asked by firms like Graviton or Tower Research.

#HFT #CPP #BinarySearch #90DayChallenge #MAIT #FedoraLinux

Watch Day 2 on Youtube here

I’ve officially kicked off a 90-day challenge to break into top HFT firms like Graviton, Tower Research, and Jane Street. My goal isn't content creation; it’s about maintaining discipline and improving my ability to explain complex code—a critical skill for high-stakes interviews. I’m keeping it raw: no editing, no flashy setups, just engineering focus.

Finding Signal in the Noise

• The Environment: I'm recording this with a Bhagavad Gita path happening right outside my house—it's very loud, but the work doesn't stop.

• The "Rubber Duck": Meet Mr. Pangu, my penguin interviewer who helps me talk through logic when I get stuck.

• The Tech: Running Fedora Linux with Hyperland on an Asus TUF gaming laptop. I’m an engineer first, so I’m using my built-in webcam to avoid wasting time on production.

Technical Deep Dive: C++ for High Performance

1. Struct Padding & Memory Alignment

I implemented a MarketOrder struct to demonstrate why memory layout is critical in high-frequency trading.

• The Discovery: A struct with a double, int, char, and bool might seem like 14 bytes, but my system showed 16 bytes.

• The Logic: On a 64-bit system, the compiler adds padding to ensure data is aligned to 8-byte boundaries.

• The Optimization: By reordering members to put the largest types first, I reduced a different struct version from 24 bytes to 16 bytes.

• The HFT Impact: This saves 8 bytes of memory per order, which can prevent millions of CPU cache misses and reduce the memory footprint by 33%.

2. Production-Level Coding Standards

• No bits/stdc++.h: I'm moving away from competitive programming shortcuts and explicitly including headers like <iostream> for cleaner, production-ready code.

• Namespace Discipline: I've stopped using using namespace std; to avoid naming conflicts, which is standard practice in high-performance environments.

• Buffer Management: Using \n instead of std::endl to avoid unnecessary buffer flushes, which can be a performance bottleneck.

DSA: Binary Search Mastery

I tackled two fundamental problems that test precision with boundary conditions:

• LeetCode 35 (Search Insert Position): Implemented binary search using an overflow-safe midpoint calculation: low + (high - low) / 2.

• LeetCode 34 (First and Last Position in Sorted Array): This involved running binary search logic to find the specific range of a target value in O(log N) time.

Current Status: Day 2/90 Complete.

Next Steps: Continuing to strip away "content creator" habits and focus purely on nanosecond-level optimizations.

#HFT #C++ #90DayChallenge #LowLatency #QuantTrading #MAIT

  lower_bound(arr.begin(),arr.end(),target) // O(log n) Time Complexity STL function

I will improve my writing here and keep it in minimum as I have given up

1. Instagram

2. Snapchat

3. Girls ( I am 23 and have no girlfriend )

4. Porn ( Yes, I was an addict, but I am improving Day-by-Day ) [It’s part of a mentality change]

I have become religious and follow the principles of the Bhagavad Gita!

Bye and thanks for Reading!

#include <iostream>
#include <vector>
int main(){
    std::vector<int> v;
    std::cout<<"Initial Capacity: "<< v.capacity() <<"\n";

    for (int i = 0; i < 10; ++i){
        v.push_back(i);

        std::cout<<" Size: " << v.size()
                 <<" | Capacity: "<< v.capacity()
                 <<" | Address of v[0]: " << &v[0] << "\n";
    }
    return 0;
}

This code scales, but it has a problem known as the doubling strategy!

• but, it’s not a problem, basically we all know vector is a dynamic array

• but what makes it dynamic is the doubling strategy

• the vector starts with 0 initial capacity, then we add 1, so it increase it’s capacity by 1

• basically the whole vector moves to new position of size: 1 , now we add another element: 2,

• it resizes itself to 1×2 = 2 , not resize but move to a new space with size:2

• now another element:3 (here) , it resizes 2×2=4, and so on,

• the vector sizes become 0,1,2,4,8,16…

• this is a problem for high frequency trading firm

• THE SOLUTION(WRONG ONE: My thought) → we use v(10) at the starting of the vector while initializing

vector<int> v(10);

• what’s wrong? it actually makes an array with 10 zeroes initialized

• and the element to be added will go to 11th position where size of v: 10×2=20;

• LOL

• correct approach? use reverse()

vector<int> v;
v.reserve(10);

• it tells the compiler, we are expecting 10 values here, until then don’t resize!!!!!

Bye and Jai Shree Ram!

useContext

The most important thing in daily life of a ReactJS developer maybe the context providers.

NextJS provides them pre written and ready to use. But when I tried to understand them.

Man oh man, they are simply really good.

createContext allows to make the parameters for the context provider.

This thing solves the problem of prop-drilling. Any ReactJS developer may tell you that how it is a pain in the 🌝.

useContext allows you to pass the context in the top most file and use it anywhere.

Damnnnn!!!!!

Now I know why everyone loves React ecosystem.

Resources:

• Prop-drilling=>

  https://react.dev/learn/passing-data-deeply-with-context

• useContext=> https://react.dev/reference/react/useContext