Forem: SinghDevHub

how we prevent ai agent's drift & code slop generation

SinghDevHub — Thu, 22 Jan 2026 18:17:55 +0000

At TraycerAI we reduced hallucinations, code slop generation and solved agent's drift. Finally you can ship complex features, end to end products with world's first AI product planner.

Traycer is built on the core philosophy of Spec driven development and is way ahead than anyone due to its approach.

Lets discuss, how we've achieved this

AI agents that write code have a dirty little secret, they drift, hallucinate, and generate confident garbage. After building AI agents that have executed large scale agentic workloads, here's what actually works to stop them.

The Core Problem

AI coding agents aren't stateless chatbots. They explore codebases, make decisions, loop through tool calls, and build context over time. Without proper guardrails, they drift from the original task, get stuck in infinite exploration cycles, or generate plausible-looking code that's fundamentally wrong.

The solution isn't one clever trick, it's a system of interlocking safeguards.

Circuit Breakers: Hard & Soft Thresholds

Every agentic loop needs circuit breakers. We implement a dual-threshold system:

At the warning threshold, the agent gets a nudge: "You've explored the codebase enough. Time to deliver your response." This redirects without forcing termination.

At the hard threshold, we force completion. The agent must use whatever context it has gathered and produce output, no more exploration allowed. Without this, agents will happily research forever, burning tokens while producing nothing.

Structured Output Contracts

Never trust raw LLM output. Every response passes through strict validation:
JSON/XML schema validation
Type checking against expected structures
Completeness verification (did we get all required fields?)

If output is malformed, we retry with explicit correction instructions. If it's still broken after retries, we fail gracefully with actionable error messages, not silent corruption.

Explicit Termination Tools

Here's a subtle but critical insight: don't let agents decide when they're "done" through natural language. Give them explicit termination tools they must invoke, complete_review, submit_plan, finish_verification.

This creates auditable completion points. We know exactly when and why an agent decided to terminate, and we can validate that the termination was legitimate.

Persistent State Management

Agent state is precious.
Connection tracking ensures state survives interruptions. LRU caching keeps frequently-accessed objects in memory for performance. If the agent crashes mid-task or the user closes their laptop, we can resume from the last checkpoint, not restart from scratch.

This isn't just about reliability. It's about building user trust. Nothing kills confidence faster than losing 10 minutes of agent work to a network hiccup.

AI Reviewing AI

This sounds counterintuitive, but it works: after code generation, a separate verification agent reviews the output with fresh eyes.

Does the change align with user intent?

Are there unintended side effects?

Did it miss edge cases the original agent overlooked?
Different model, different prompt, different perspective. The verification agent has no investment in defending the original output, its only job is finding problems.

Provider Redundancy

Single LLM provider equals single point of failure. Our routing layer maintains multiple providers per request type with automatic failover. If one provider hits rate limits or returns errors, we transparently switch to the next.

The agent doesn't even know which provider responded. This abstraction keeps the core logic clean while giving us resilience against the inevitable API hiccups.

Scope Boundaries

Vague scope produces vague output. We explicitly constrain agents: stay focused on the codebase, don't venture into production deployment, don't assume access to external systems you can't verify.

When agents know their boundaries, they make better decisions within them.

What Doesn't Work

A few anti-patterns we've learned to avoid:

"Just tell the agent to be careful" :- Prompting for carefulness doesn't prevent systematic drift
Single retry on failure :- Real-world errors need exponential backoff and provider failover
Implicit completion detection :- "The agent stopped talking, so it must be done" is a recipe for incomplete work
Trusting token counts for progress :- More tokens doesn't mean more useful work

The System, Not The Trick

Preventing AI agent drift isn't about one clever technique. It's about building a system where every layer catches what the others miss:

Thresholds prevent infinite loops. Validation catches malformed output. Persistent state enables recovery. Verification catches logical errors. Redundancy handles infrastructure failures.
Each safeguard is simple. Together, they create reliable agents.
Build the system. Don't hope for the best.

PS: These are patterns we’ve found effective across multiple agent systems.

What's your biggest challenge with AI agent reliability?

finally sharing what we built with our dev community

SinghDevHub — Fri, 16 Jan 2026 09:53:14 +0000

how we built the most advanced ai product planner

SinghDevHub ・ Jan 16

#ai #rag #programming #product

how we built the most advanced ai product planner

SinghDevHub — Fri, 16 Jan 2026 09:43:02 +0000

intro

𝐒𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐈𝐬𝐧’𝐭 𝐚 𝐒𝐢𝐝𝐞𝐰𝐚𝐥𝐤 – 𝐈𝐭’𝐬 𝐚 𝐂𝐢𝐭𝐲

unplanned codebases are like unplanned cities: brittle, inconsistent, and costly to extend.
scalable software, like civil infrastructure, needs clear specs, deliberate architecture, and continuous verification.
skipping these, especially when AI does the typing, leads to rigid, unmaintainable systems.

models as humans reading a book

1️⃣ when you are reading a book, you carry your attention with yourself. you tend to forget irrelevant information and retrieve the important one. this keeps your mind/attention on the track.
2️⃣ but models don't have the same capabilities as human's brain. they go offtrack when fed up everything at once. models do not act phase by phase. models do hallucinations as they do a lot of things at once.
3️⃣ indexing the book before reading, skipping irrelevant chapters & focusing attention on most important words can give you the whole context. this is how we as humans treat our books.

tweaking this same thinking to LLM models, what if we can provide them relevant information & stop telling them everything at once (context bloat).

❓what if we ask our models to do the thing which they are really good at? what if we tell them to do work in phases? what if we spawn an army of agents to do work & collaborate on the tasks after they break down the tasks?

😎 YES, this is exactly like tackling a big problem in smaller sub problems which we proudly call as divide & conquer in computer science's world

become an orchestra not an oracle

assume having a god-model which performs really well when it starts its work but forgets things as it proceeds with the task. that is what an oracle tries to do & hence we see a lot of errors also being generated from a god agent. doing everything at once will drift the agent and going offtrack in code-generation means a lot more iterations.

⚡️that's why we built TraycerAI :- The ultimate AI product planner
the architecture: an ensemble of specialists

instead of a single "god-model" that tries to be a jack-of-all-trades, Traycer operates as a coordinated ensemble. we’ve decoupled intelligence from retrieval, ensuring that our "thinkers" aren't distracted by the "noise" of raw data gathering.

the orchestrator (sonnet-4.5): acts as the conductor. it handles high-level reasoning, complex planning, and task decomposition. it doesn’t get its hands dirty with file searching; it directs the flow.
the critics (GPT-5.1): specializing in code analysis and verification. while one model builds the plan, another, with a different "personality" and training bias, critiques the output to catch regressions.
the scouts (grok-4.1-fast & parallel.ai): these are our high-speed units. they fan out across your codebase and the web in parallel to gather context. they provide the "raw facts" back to the orchestrator without adding their own editorial bias.

defining the loops: outer vs. inner (again)

to understand Traycer, you have to understand where it sits in the development lifecycle. most AI tools are focused on the inner loop, but Traycer owns the outer loop.

the inner loop: the "How"

this is the tactical layer. it’s the act of writing code, patching lines, and running local tests. it’s where your code-gen agents live. it answers the question: "Can you write this specific function for me?"

the outer loop: the "Why" and "What"

Traycer lives here. the outer Loop is the strategic layer that governs the entire change process. it doesn’t just write code; it manages the intent.

strategic planning: before a single line is written, Traycer decomposes a high-level prompt (e.g., "Add rate limiting") into a phased implementation spec.
context synthesis: It determines which files matter across a massive repository, long before a code-gen agent starts its work.
final verification: after the inner loop finishes, the outer loop steps back in to verify the changes against the original architectural constraints.

📍 key takeaway: by separating these loops, Traycer ensures that the "Thinking" (Outer Loop) is never compromised by the "Doing" (Inner Loop). you get the speed of parallel agents with the oversight of a senior architect.

if you are building end to end products, features, you should definitely checkout our EPIC mode in Traycer which:-

capture user's intent really really well
generate LLD diagrams, wireframes like a senior engineer
interviews you like an software architect before generating code
and verifies like a senior QA to detect edge cases

& you will get amazed how accurate your features, products will come out

Vibe coding method that actually works

SinghDevHub — Tue, 13 Jan 2026 08:58:23 +0000

📍 Engineering's current situation

You might have heard this already a ton of times that software engineers are gonna get replaced with AI systems, agents and tools.

Well, We will not comment too much on this particular thing as no one is clear about this. But few predictions/things already happening in the industry:-

1️⃣ small teams are getting really really effective/productive
2️⃣ people with agency and intent are getting preferred over people who are very skilled or smart
3️⃣ companies will move even faster than before
4️⃣ softwares building themselves

😳 Examples:-

claude code is being built using claude
Traycer is being built using TraycerAI

But there is one common thing in every organisation that it is not about:-
❓should you use AI or not? It is about:- how you should use AI.

A lot of people don't know if they are doing vibe coding or doing AI Assisted coding. Yep, there is a huge difference in Vibe Coding & AI Assisted coding.

📍 Usual way of vibe coding

Vibe coding workflow generally looks like this:-

You have an agentic IDE (cursor, windsurf) or CLI agents like (claude code, gemini cli)
You put a prompt in the chat window
Your agent reads the prompt, plans and then start generating code

This method works on very small features or when you are starting afresh, because:-

starting with fresh context or instance of agent, works for some time
as you keep on generating code, agents starts drifting from the actual intent that human asked the agent to code for
small & simple features can be implemented by most of the LLM models like claude, grok etc

📍 When things actually break ?

But as soon as someone starts working on larger codebases, complex features or end to end products, Agents struggle a lot because:-

they start drifting away from human given prompt or intent
they start coding worse as context window fills up
they start hallucinations with confidence with no verification loops

👉 Because of which, users generate thousands of lines of code and realise nothing works. And then refactoring that codebase is a very tedious task and a lot of iterations comes into the play.

And this struggle is causing developers a pseudo productivity boost, a lot of iterations and headaches.

So how should we vibe code then ??

No, above picture doesn't refer to how you should code 🤪

Coding is still a fundamental problem solving method where structure wins even after so many code generation LLM models. Catching it up using first principles it is:-

writing a PRD (product/feature requirement doc)
dividing a PRD into Specs
making Tech docs and then sub-tasks
assigning sub tasks to your team so that they can finally code
verification of the implementations

And this is where Inner loop solves your problem, which is code generation.

But have you noticed which part is missing ???

Yes, exactly the outer loop.

📍 The Outer Loop

Missing pieces because of which LLMs are still not capable of coding are:-
1️⃣ writing a PRD (product/feature requirement doc)
2️⃣ dividing a PRD into Specs
3️⃣ making Tech docs and then sub-tasks
⚠️ - assigning sub tasks to your team so that they can finally code (using Inner loop or LLMs here)
4️⃣ verification of the implementations

This is where a new field shines:- Spec Driven Development.

A lot of products are trying to solve Spec driven development which does generate PRDs, plan really well, verifies each agent's code step and prevent agents drifting away from user' intent.

Products which are in this space are:- Traycer, Kiro, Spec-kit

But my friends are obsessed with Traycer because of their features like EPIC mode which is highly intuitive.

Traycer solved few problems which no one is able to solve yet:-

capturing human intent from a normal simple prompt
prevents agents from deviating from the intent
consume less tokens and prevents context bloating
verifies your each change so that you dont ship hallucinations with confidence

Here is a sneak peak how TraycerAI EPIC mode looks like:-

TraycerAI is my partner nowadays because it acts my senior engineer instead of just an agent. Highlighting few features:-

It starts with a simple prompt
Then it interviews you around problem statement, tech stack, edge cases and other high level questions
Then it generates PRDs, Specs, Tech flow, Wireframes, Sequence and user flow diagrams
And finally, it breaks the plan into smaller tickets so that you can handover these tickets to any AI agent like claude, grok, cursor IDE etc
and then it verifies each and every change and prevents your agents to drift/deviate in false direction

📍 Recently we shipped products like:-

building your own redis
building my own whatsapp that supports semantic search across messages

And many more projects we are building and loving the EPIC mode ❤️

Right way to vibe code that actually works

SinghDevHub — Sun, 11 Jan 2026 13:05:49 +0000

📍 Engineering's current situation

You might have heard this already a ton of times that software engineers are gonna get replaced with AI systems, agents and tools.

Well, We will not comment too much on this particular thing as no one is clear about this. But few predictions/things already happening in the industry:-

😳 Examples:-

claude code is being built using claude
Traycer is being built using TraycerAI

But there is one common thing in every organisation that it is not about:-
❓should you use AI or not? It is about:- how you should use AI.

A lot of people don't know if they are doing vibe coding or doing AI Assisted coding. Yep, there is a huge difference in Vibe Coding & AI Assisted coding.

📍 Usual way of vibe coding

Vibe coding workflow generally looks like this:-

You have an agentic IDE (cursor, windsurf) or CLI agents like (claude code, gemini cli)
You put a prompt in the chat window
Your agent reads the prompt, plans and then start generating code

This method works on very small features or when you are starting afresh, because:-

starting with fresh context or instance of agent, works for some time
as you keep on generating code, agents starts drifting from the actual intent that human asked the agent to code for
small & simple features can be implemented by most of the LLM models like claude, grok etc

📍 When things actually break ?

But as soon as someone starts working on larger codebases, complex features or end to end products, Agents struggle a lot because:-

they start drifting away from human given prompt or intent
they start coding worse as context window fills up
they start hallucinations with confidence with no verification loops

👉 Because of which, users generate thousands of lines of code and realise nothing works. And then refactoring that codebase is a very tedious task and a lot of iterations comes into the play.

And this struggle is causing developers a pseudo productivity boost, a lot of iterations and headaches.

So how should we vibe code then ??

No, above picture doesn't refer to how you should code 🤪

Coding is still a fundamental problem solving method where structure wins even after so many code generation LLM models. Catching it up using first principles it is:-

writing a PRD (product/feature requirement doc)
dividing a PRD into Specs
making Tech docs and then sub-tasks
assigning sub tasks to your team so that they can finally code
verification of the implementations

And this is where Inner loop solves your problem, which is code generation.

But have you noticed which part is missing ???

Yes, exactly the outer loop.

📍 The Outer Loop

This is where a new field shines:- Spec Driven Development.

A lot of products are trying to solve Spec driven development which does generate PRDs, plan really well, verifies each agent's code step and prevent agents drifting away from user' intent.

Products which are in this space are:- Traycer, Kiro, Spec-kit

But my friends are obsessed with Traycer because of their features like EPIC mode which is highly intuitive.

Traycer solved few problems which no one is able to solve yet:-

capturing human intent from a normal simple prompt
prevents agents from deviating from the intent
consume less tokens and prevents context bloating
verifies your each change so that you dont ship hallucinations with confidence

Here is a sneak peak how TraycerAI EPIC mode looks like:-

TraycerAI is my partner nowadays because it acts my senior engineer instead of just an agent. Highlighting few features:-

It starts with a simple prompt
Then it interviews you around problem statement, tech stack, edge cases and other high level questions
Then it generates PRDs, Specs, Tech flow, Wireframes, Sequence and user flow diagrams
And finally, it breaks the plan into smaller tickets so that you can handover these tickets to any AI agent like claude, grok, cursor IDE etc
and then it verifies each and every change and prevents your agents to drift/deviate in false direction

📍 Recently we shipped products like:-

building your own redis
building my own whatsapp that supports semantic search across messages

And many more projects we are building and loving the EPIC mode ❤️

Everyone is a Product engineer now

SinghDevHub — Wed, 07 Jan 2026 08:50:54 +0000

😭 Everything is AI generated now a days, but this blog is not because I am sharing my observations about what is happening in the industry.

😎 With each new day passing we are seeing new and new AI tools and people are trying every new tool in the hope that this tool will finally fix their life.

😭 But after they try they come to know that they still can't earn without work.

🤪 Personally, people after trying GPT, Claude, Grok they know exactly which agent is for what task.

someone is good at coding
someone at rage baiting on X
someone at reasoning

👉 But all of them are missing to capture user's intent. That's when i came across Spec Drive Development (SDD) which made me a product engineer from a software developer.

Now, i hardly write any code, but always explaining my intent to these AI tools. But it is working honestly.

I am using http://traycer.ai/ from past few months and now i do write prompt it does:-

generate specs
generate phases
verifies each step
gives me wireframes to visualise before writing any code
biggest part is i am spending lot less to get far good results on large codebases as compared to using one model on the entire code like claude or grok

Traycer is an orchestration of agents, sub-agents that does my work. The only thing is i have to think about my intent and requirements.

🔥 I am using its YOLO mode, sometimes phase breakdown and wireframes are cherry on the top.

😏 Now everytime i have to think what to fix, build and ship. I have to think what and why instead of how. I mean i used to think how when using claude code, cursor because they drift too much when your code grows.

For example:-

claude code goes to walk after compaction
grok is still trying to do rage bait on X
GPT generates too much code that it doesn't understand after a point of time

These folks are good when handled carefully by a parent like Traycer.

See traycer in action:-

I can clearly see the user flows through sequence diagrams, flow charts
I can see wireframes/UI before even code generation has started
My intent is separated into smaller tickets that i can edit
Then i can choose my children to do the work (claude, grok, gpt) and verify at the completion of each phase

So far, I am loving this product. and paying too less i think sometimes.

Basics of Stack, Heap, memory management, VM & JVM

SinghDevHub — Mon, 05 May 2025 16:08:45 +0000

🚀 Have you ever wondered when you open up any program like VLC Player (music player)

What happens?
How it comes on your PC's screen?
How it uses your resources and runs on your machine?

Well, there are many workers who are responsible of running a process.

📔 But wait before starting anything, what is a program and process ?

📍 Program

Whenever someone writes code lines in a file (let say java) which we call a set of instructions

class Test {
    public static void main (String[] args){
         System.out.println("Hello world");
    }
}

Above code written is nothing but we are trying to tell the computer that load the Test class, call the main() method and print "Hello world" on our screen.

Now this set of instructions File is called a program (a fancy word) and when we run (execute) our program
it takes some resources like some share of CPU, memory and storage and program runs.

Running program is called a process, yes another fancy word

😢 Note:- Well, Interesting thing is our computer doesn't understand ENGLISH at all. It only understand bits which have only two values like 1 and 0.

😎 That is where your compiler comes into the picture.

Now, what the heck is compiler ?

📍 Compiler

Again, compiler is an another fancy word but a translator and inspector. Compiler is a program written by compiler programmers which convert english written files (code files like java, js, c++ etc files) to assembly code.

😅 Assembly code is another type of format which is more closer to the machine (our PC), for example

section .text
global main_entry_point

main_entry_point:
    sub rsp, 40
    mov rax, [address_of_System_out_object_pointer]
    lea rdx, [address_of_hello_world_string_object]
    mov rdi, rax
    mov rsi, rdx
    call address_of_native_println_implementation
    add rsp, 40
    ret

Above code is assembly code which is hard to write for software engineers but easy for assembler to understand and convert to machine code. And machine code is what machines understands.

01010101                  ; push rbp
01001000 10001001 11100101    ; mov rbp, rsp
01001000 10000011 11101100 00101000 ; sub rsp, 0x28
01001000 10111000 <64 bits of address_ptr> ; mov rax, address_of_System_out_object_pointer
01001000 10001001 01000101 11111000 ; mov [rbp-0x8], rax
01001000 10111010 <64 bits of address_str> ; mov rdx, address_of_hello_world_string_object
01001000 10001001 01010101 11110000 ; mov [rbp-0x10], rdx
01001000 10001011 01000101 11111000 ; mov rax, [rbp-0x8]
01001000 10001001 11100111    ; mov rdi, rax
01001000 10001011 01010101 11110000 ; mov rdx, [rbp-0x10]
01001000 10001001 11010110    ; mov rsi, rdx
11101000 <32 bits of offset>  ; call address_of_native_println_implementation
11001001                  ; leave
11000011                  ; ret

📍 Process of conversion so far looks like

Above picture shows the execution of C++ program, where C++ file is compiled by g++ (compiler of C++) which is a program responsible of converting C++ code to assembly code.
Then assembler is responsible of converting assembly code to machine code which finally runs on our machine.

✅ But here is a very important point to notice, which is C++ is not a language like JAVA which is write once run anywhere (WORA).

Because when C++ code is converted, it is directly converted to machine code with no intervention. Machine code generation is generated according to the architecture & operating system that our machine has.

💯 For ex: we have x86, arm based processors which has different nature of understanding code at machine level. Hence you can't run same code running on Apple mac M1 (arm based processor) on x86 based processor (intel i9).

That's why, in JAVA there is one intermediator step introduced which is virtual machine & byte code.

📍 Virtual machine & Byte Code

Virtual machine as name suggests is a machine which is not real but mimic our original machine.

⭐ Virtual machine is a software written which takes few %age of CPU, memory and storage and runs as a mini computer inside your main computer. Hence, we can run multiple virtual machines on a single host (main) machine.

Pros of VM:-

software developer using VM has a lot of control because we can tweak stuff at software level which is hard to do at hardware level
VM can be made secure and can act as intermediate step before your program goes to hardware and execute

❤️ Due to above reasons a Virtual machine specific to Java was introduced which is Java virtual machine (JVM)

People wrote JVM for x86, arm architectures. People wrote for windows, linux and other Operating systems. Which is why due to the availibility of JVM on all machines JAVA can run on any machine.

📍 This is how JAVA program runs on our machines:-

As you can see that intermediate step here is JVM which is a program written by developers which takes intermediate code file (byte code) and JVM understands byte code and is responsible of converting bytecode to machine code and then it runs.

📍 Here you can see:-

compiler doesn't care about what underlying OS or architecture (x86, arm) is
It just knows how to convert and it does
Rest work is for JVM which is built according to the underlying OS and architecture
Hence software developers (who focuses on Main.java) they don't care about what their OS and architecture is, JVM will handle everything.
On the other hand, if you would have noticed C++ code differs on windows and linux. libraries also do differ with x86 and arm architecutres

📍 Let's see the conversion of code in Java

Java file that we write

// File: Test.java
class Test {
    public static void main (String[] args){
        System.out.println("Hello world");
    }
}

File that compiler translates to (Don't worry about the details, we dont have to fear this syntax)

Compiled from "Test.java"
class Test {
  // Default constructor added by javac
  Test();
    Code:
       0: aload_0       // Load 'this' onto the operand stack
       1: invokespecial #1 // Method java/lang/Object."<init>":()V (Call superclass constructor)
       4: return        // Return from constructor

  public static void main(java.lang.String[]);
    Code:
       // --- The interesting part ---
       0: getstatic     #2 // Field java/lang/System.out:Ljava/io/PrintStream;
                            // Pushes the static field System.out (a PrintStream object) onto the stack

       3: ldc           #3 // String "Hello world"
                            // Pushes the String "Hello world" from the constant pool onto the stack

       5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
                            // Pops the string and PrintStream object, calls the println method

       8: return        // Return void from main
}

JVM who converts bytecode to machine code and runs on the machine

📍 When Program runs

When program runs (machine code) on your machine. It takes memory, cpu and storage while running. while running, process treats memory as stack and heap which acts as static and dynamic memory respectively.

Stack

import java.util.*;

public class Main {
    private static void printHello(){
      System.out.println("Hello world");
      Car bmw = new Car();
    }

    public static void main(String[] args) {
      printHello();
  }
}

stack memory holds local variables, function parameters, pointer to dynamic memory if any list, object (bmw in above example) is created

Above picture states that first we call main() then we push printHello() to stack and then we push println() which prints the output. Then we create an object on heap because objects are created on Heap memory and pointer to the object memory location is stored in the stack itself.

Note:- Stack flushes automatically as soon as function completes its execution while Heap does not flushes automatically

To flush the heap, there is another program written which runs and flushes the memory on heap allocated in our java program
that program is called garbage collection

CPU cycles, memory representation:- binary numbers and Hexadecimal base and Hertz

When we look at the clock we measure time using seconds, minutes or hours. Similarly, the unit of work for our CPU is called its CPU cycle.

Every CPU has its clock speed or frequency. for example AMD ryzen 7 9800x3D has 4.7GHz (1Giga = 1 billion) as its base frequency. Which means in one seconds it can run 4.7 billion instructions.

Instructions are nothing but our code lines that we write in simple words.

Question:- Can you think how much approximate work CPU has to do to perform 2+4 calculation ?

📍 Next comes memory representation

Memory is represented in hexadecimal base. What is hexadecimal base ??

in decimal space we have numbers as 0,1,2,3,4,5,6,7,8,9
in binary space we have numbers as 0,1
in hexadecimal space we have 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

Conversion of binary, hexa, deci base to decimal numbers that we humans understand:-

We represent memory in hexadecimal base (16 base, because we have 16 numbers instead of 10 numbers that we have in decimal base)

0x45FBC memory means:-

Writing USB driver for Linux in C

SinghDevHub — Wed, 04 Dec 2024 10:42:20 +0000

How USB got detected when we plug it in

I am running Ubuntu in VM:- https://www.youtube.com/watch?v=O19mv1pe76M (How to setup on Mac m1)

When we plug in our USB, ever thought what happens. Well, whenever we connect devices like USB in our PCI slot (Peripheral component interface) it gets detected in kernel space by the device controller which doesn't depend on the driver existence.

Although, default drivers exist in most of the linux distros. After plugging the device, hardware controller driver do detect the USB and it translates the low level information for the higher layers adhering to the USB protocol.

This information is detected and passed towards generic USB core layer(usbcore) in kernel layer which completes the device detection.

These controller drivers are typically coming from these categories:-

EHCI (Enhanced Host Controller Interface) for USB 2.0.
XHCI (eXtensible Host Controller Interface) for USB 3.0 and later.
OHCI (Open Host Controller Interface) for older USB 1.1 systems.
UHCI (Universal Host Controller Interface) for certain USB 1.1 implementations.

Let's go in some more depth, how information is detected and retrieved

Install some of the things if not installed already

sudo apt get make
sudo apt-get install linux-headers-$(uname -r)
sudo apt install build-essential
sudo apt install gcc-13
sudo apt install g++-13

Device Firmware Initialization: The PCI device's firmware writes its configuration data (like Vendor ID, BARs) into its PCI configuration space.
PCI Controller Enumeration: The PCI controller scans devices and collects this configuration data.
Kernel PCI Subsystem: The Linux kernel reads the configuration space data during boot or when a hot-plugged device is detected.
Device Drivers: The kernel matches the Vendor ID and Device ID with the appropriate driver and initializes it.

Note:- every driver, code, documentation and implementation can be referred in linux source code.

follow this to build linux system in local system for the reference:-
https://phoenixnap.com/kb/build-linux-kernel

We will be writing USB driver for our Sandisk Pendrive which will talk to the USB controller using the interface given in the linux.

To register and de-register the usb we have usbcore apis which are present in linux/usb.h

int usb_register(struct usb_driver *driver);
void usb_deregister(struct usb_driver *);

// #include <stdio.h> Cant use them as they operate in user mode, in kernel mode we cant use them
#include <linux/usb.h>
#include <linux/module.h>

static struct usb_device *device;

static struct usb_device_id skel_table[] = {
    {USB_DEVICE(0x0781, 0x5567)},
    {}};
MODULE_DEVICE_TABLE(usb, skel_table);

static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
    printk(KERN_INFO "Pen drive probed\n");

    return 0;
}

static void skel_disconnect(struct usb_interface *interface)
{
    usb_put_dev(device);
    printk(KERN_INFO "Pen drive removed\n");
}

static struct usb_driver skel_driver =
    {
        .name = "usb_driver",
        .probe = skel_probe,
        .disconnect = skel_disconnect,
        .id_table = skel_table,
        .supports_autosuspend = 1,
};

static int __init usb_skel_init(void)
{
    int result;
    result = usb_register(&skel_driver);
    if (result < 0)
    {
        pr_err("usb registeration failed with %s\n", skel_driver.name);
        return -1;
    }
    printk(KERN_INFO "USB initialised\n");
    return 0;
}

module_init(usb_skel_init);

static void __exit usb_skel_exit(void)
{
    usb_deregister(&skel_driver);
}

module_exit(usb_skel_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("lovepreet");
MODULE_DESCRIPTION("USB pendrive registration driver");

If getting
insmod: ERROR: could not insert module usb_driver.ko: Key was rejected by service

follow:- https://askubuntu.com/questions/762254/why-do-i-get-required-key-not-available-when-install-3rd-party-kernel-modules

Understanding more about usb structs (defined in linux/usb.h though) in sequence :-

struct usb_device
{
    ...
    struct usb_device_descriptor descriptor;
    struct usb_host_config *config, *actconfig;
    ...
};
struct usb_host_config
{
    struct usb_config_descriptor desc;
    ...
    struct usb_interface *interface[USB_MAXINTERFACES];
    ...
};
struct usb_interface
{
    struct usb_host_interface *altsetting /* array */, *cur_altsetting;
    ...
};
struct usb_host_interface
{
    struct usb_interface_descriptor desc;
    struct usb_host_endpoint *endpoint /* array */;
    ...
};
struct usb_host_endpoint
{
    struct usb_endpoint_descriptor  desc;
    ...
};

Now we can use these hierarchical structs to print some more information about the USB

Complete code for the driver is:-

// #include <stdio.h> Cant use them as they operate in user mode, in kernel mode we cant use them
#include <linux/usb.h>
#include <linux/module.h>

static struct usb_device *device;

static struct usb_device_id skel_table[] = {
    {USB_DEVICE(0x0781, 0x5567)},
    {}};
MODULE_DEVICE_TABLE(usb, skel_table);

static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
    struct usb_host_interface *iface_desc;
    struct usb_endpoint_descriptor *endpoint;
    int i;
    iface_desc = interface->cur_altsetting;
    printk(KERN_INFO "Pen i/f %d now probed: (%04X:%04X)\n",
           iface_desc->desc.bInterfaceNumber,
           id->idVendor, id->idProduct);
    printk(KERN_INFO "ID->bNumEndpoints: %02X\n",
            iface_desc->desc.bNumEndpoints);
    printk(KERN_INFO "ID->bInterfaceClass: %02X\n",
            iface_desc->desc.bInterfaceClass);

    for(i = 0; i< iface_desc->desc.bNumEndpoints; i++){
        endpoint = &iface_desc->endpoint[i].desc;
        printk(KERN_INFO "ED[%d]->bEndpointAddress: 0x%02X\n",
                i, endpoint->bEndpointAddress);
        printk(KERN_INFO "ED[%d]->bmAttributes: 0x%02X\n",
                i, endpoint->bmAttributes);
        printk(KERN_INFO "ED[%d]->wMaxPacketSize: 0x%04X (%d)\n",
                i, endpoint->wMaxPacketSize,
                endpoint->wMaxPacketSize);
    }
    device = interface_to_usbdev(interface);

    return 0;
}

static void skel_disconnect(struct usb_interface *interface)
{
    usb_put_dev(device);
    printk(KERN_INFO "Pen drive removed\n");
}

static struct usb_driver skel_driver =
    {
        .name = "usb_driver",
        .probe = skel_probe,
        .disconnect = skel_disconnect,
        .id_table = skel_table,
        .supports_autosuspend = 1,
};

static int __init usb_skel_init(void)
{
    int result;
    result = usb_register(&skel_driver);
    if (result < 0)
    {
        pr_err("usb registeration failed with %s\n", skel_driver.name);
        return -1;
    }
    printk(KERN_INFO "USB initialised\n");
    return 0;
}

module_init(usb_skel_init);

static void __exit usb_skel_exit(void)
{
    usb_deregister(&skel_driver);
}

module_exit(usb_skel_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("lovepreet");
MODULE_DESCRIPTION("USB pendrive registration driver");

Manually binding the USB with own driver instead of usb-storage driver

If you are not able to see the usb being attached with usb_driver and getting attached with usb-storage

lsusb -t

Then follow these steps:-

plug pen drive
use sudo dmesg and see what is the usb sequence like

[   68.923193] systemd-journald[338]: Time jumped backwards, rotating.
[  113.120352] usb 1-5: new high-speed USB device number 3 using xhci_hcd
[  113.246983] usb 1-5: New USB device found, idVendor=0781, idProduct=5567, bcdDevice= 1.00
[  113.246989] usb 1-5: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[  113.246990] usb 1-5: Product: Cruzer Blade

Here we can see that it is usb 1-5, so we have to use this and have to unbind usb-storage

run these commands

sudo su
sudo echo -n "1-5" > /sys/bus/usb/drivers/usb/unbind (eject the usb)
sudo echo -n "1-5" > /sys/bus/usb/drivers/usb/bind (connect/binds again)
echo -n "1-5" > /sys/bus/usb/drivers/usb-storage/unbind
Now restart the OS

Now, try

sudo insmod usb_driver.ko
plug in your pen drive and check sudo dmesg
You will be able to see the USB logs being probed and all

Interesting Fact:- Now USB drive will not show in the files to transfer data because our custom driver hasn't implemented data read and write yet.

resources:-
https://sysplay.github.io/books/LinuxDrivers/book/Content/Part11.html
https://docs.kernel.org/driver-api/usb/writing_usb_driver.html

Implementing Parallel Merge Sort: 25sec vs 1.5sec

SinghDevHub — Wed, 02 Oct 2024 08:41:55 +0000

🥵 When i was in my college days, one constant thing that I didn't get why the heck are we learning CS subjects like operating systems, computer networks and data structures and algorithms.

🔥 Yes, exactly I was like this only till i discovered how to dig deeper in CS subjects and how I can use problem solving with my cs subjects.

⚡️ Last weekend, I was getting bored hence I was thinking constantly about what I should implement. So, i went back to my college days and thought of tweaking some basic sorting algorithm.

AND, Yes i implemented a Multithreaded Merge sort algorithm which took 1.5 sec on my mac m1 pro in comparison to 25 sec taken by a normal Merge sort algorithm.

If you prefer videos, Click on this one where You can go through the implementation details of the algorithm with theory:-
https://www.youtube.com/watch?v=t43U7UuVAHQ&t=247s

🫡 Merge Sort Theory (Recursion)

The fastest sorting algorithm has O(nlogn) time complexity and the there are two cool algorithms in sorting space: Merge sort & Quick Sort.

Because both of em uses recursion which is a super cool thing in Data structures and Algorithms subject (We will combine recursion with multithreading further in parallel merge sort)

Merge sort relies on recursion where we divide array/list into two parts and continue to do so, until we get single element array (Base case of recursion).
Now, Single element array is always a sorted array and this is the base case where we assume that both left and right arrays are sorted
then we try to combine them both in a resulting array and return to the upper step of our recursion tree

Now, you can notice one thing which is whenever we are dividing the array in two parts both of them are being processed in an independent manner, right?

Code of Merge sort goes like:-

#include "mergeSort.hpp"
#include <iostream>
MergeSort::MergeSort(std::vector<int> *nums){
    this->nums = nums;
}

MergeSort::~MergeSort(){}

void MergeSort::recursiveSort(int left, int right){
    if(left>=right){
        return;
    }

    int mid = left + (right-left)/2;

    recursiveSort(left, mid);
    recursiveSort(mid+1, right);

    std::vector<int> result;
    int i = left;
    int j = mid+1;

    while(i<=mid && j<=right){
        if((*nums)[i]<=(*nums)[j]){
            result.push_back((*nums)[i]);
            i++;
        }else{
            result.push_back((*nums)[j]);
            j++;
        }
    }

    while(i<=mid){
        result.push_back((*nums)[i]);
        i++;
    }

    while(j<=right){
        result.push_back((*nums)[j]);
        j++;
    }

    for(int k = 0; k<result.size(); k++){
        (*nums)[left+k] = result[k];
    }

    return;

}

void MergeSort::sort(){
    if((*nums).size() == 0){
        exit(1);
    }
    recursiveSort(0, (*nums).size());

}

🚀 You can go through the code and it will be easy to gothrough it if you can dry run a case

📍 Parallel merge sort (recursion + multithreading)

Now, there is a catch, why can't we use our 8 cores machine parallel power. instead of waiting for left part of the array to get sorted we can hand over the right array to different thread right.

Confused?? dont worry let's look at it:-

Code of the same is:-

#include "parallelMergeSort.hpp"
#include <thread>
#include <iostream>

ParallelMergeSort::ParallelMergeSort(std::vector<int> *nums) 
    : nums(nums){
}

ParallelMergeSort::~ParallelMergeSort(){}

void ParallelMergeSort::recursiveSort(int left, int right) {

    if (left >= right) {
        return;
    }
    int mid = left + (right - left) / 2;

    std::thread thread_1([this, left, mid]{ this-> recursiveSort(left, mid);});
    std::thread thread_2([this, mid, right]{ this-> recursiveSort(mid+1, right);});
    thread_1.join();
    thread_2.join();


    std::vector<int> result;
    int i = left;
    int j = mid + 1;

    while (i <= mid && j <= right) {
        if ((*nums)[i] <= (*nums)[j]) {
            result.push_back((*nums)[i]);
            i++;
        } else {
            result.push_back((*nums)[j]);
            j++;
        }
    }

    while (i <= mid) {
        result.push_back((*nums)[i]);
        i++;
    }

    while (j <= right) {
        result.push_back((*nums)[j]);
        j++;
    }

    for (int k = 0; k < result.size(); k++) {
        (*nums)[left + k] = result[k];
    }
}

void ParallelMergeSort::sort(){
   if((*nums).size()==0) {
        return;
   }
   std::thread thread_1([this] { this->recursiveSort(0, (*nums).size()-1);});
   thread_1.join();

}

You can find the complete code at:- https://github.com/singhdevhub-lovepreet/parallelMergeSort

Note:- We have also used threshold of threads here, because depending on your machine our capacity of creating new threads might get exhaust. Hence, we have to make sure when you reach a low size array, sort that in normal manner, there is no need to spawn more threads

Now, you can look that we are delegating our work to different threads and waiting for them to get finish their work. Catch here is that because we dont have any shared resource where two threads can modify stuff at the same time.

Both left and right modifications in threads are independent of each other and hence we dont have to worry about synchronization premitives/acquiring a lock here.

The difference in sorting 10^7 elements is:-

That's it for today Guys. Follow for more.....

And If you have come so far, you can also subscribe to our newsletter:- https://www.serversidedigest.com/

Thanks ❤️

Javascript Promises in depth with V8 engine internals

SinghDevHub — Mon, 09 Sep 2024 15:29:02 +0000

😅 Being a single threaded language most of the people think that Javascript or NodeJS is slow and not scalable. Python and JS be like:-

Well, it depends. If your service is I/O (input output like file reading, DB call, Http call etc) heavy which means it has dependency on other resource being read or written.

⚡️ There, NodeJS performs good as compared to other stacks in general when your service is IO heavy instead of CPU heavy.

❓ This is because NodeJS or JS has something like handing over its work to the underlying thread of the Operating system to carry out IO execution.

It passes the callback (a function) to that thread and continue with the execution of other instructions in the code, which is called async programming also in fancy terms.

Well Well Well, Let's take a step back and understand what we wrote above:-

Blocking nature of JS

Javascript is a single threaded language and hence can work on one task at a time unlike Java where multiple threads are present to handle workload in parallel (multithreading).
So, if one function/instruction is running, next instruction will wait for this instruction to get completed and we can't run them in parallel.

Let's see how one instruction blocks another one:-

✅ You can refer video explanation (in english) with code examples and v8-engine internals here:- https://www.youtube.com/watch?v=JN89L2SqPA8

Non blocking nature

Now, in JS runtime environment (NodeJS) we have some C++ APIs that have some functions like setTimeout, Promises, localStorage which are executed by the threads of our Operating systems, not by the main JS thread.

You can see the right box having C++ APIs here:-

Whenever, we perform IO through any C++ API like executing a promise , performing HTTP call or DB operation etc JS main thread hands over the main work to the OS thread and the main thread of JS continues working on other code and doesn't wait for the Async code to run.
It provides a callback (a function) to execute when call stack gets empty (call stack has only the sync code and async code goes to microtask or task queue)
Event loop, loops through these queues when call stack gets empty & put the callbacks from these queues to the main stack and returns the result.

For more in depth details of How promises are implemented in C++ code, refer this:- https://www.youtube.com/watch?v=JN89L2SqPA8

🔥 Follow for more such articles...

How to implement a Distributed Lock using Redis

SinghDevHub — Sat, 31 Aug 2024 09:55:27 +0000

I am Dumb

Well, whenever we work in our local system everything works as butter. That is why we call "No better place than 127.0.0.1" but WAKE UP TO THE REALITY

Well things not always work in production as expected. Mostly when you are running multiple instances of your application.

🚀 As you can see that if multiple instances of our application are running and let's say that our client make a request to mark a user as a paid user in our DB.

Client will request our server
Request will reach at our load balancer
And one of the instance will get the request and will make a write query into our DB

It seems alright right? No problem till now right.

Well, yes till now there is no problem. But what if we want to write a business logic like:-

fetch the user from the DB
check if user is a free user or already paid
if free, then mark it paid and save in the db
if paid, send "Already paid" in the response.

⚡️ As we know that (assume we are using MySQL here) MySQL DBs are ACID compliant which means any query will be atomic and isolated. which means MySQL query will be run in atomic way, either it will pass or fail. But it will not quit in between.

🤔 But there is one issue here. Think, Think....

Step 1: We are fetching user (Atomic transaction)
Step 2: Running some business logic in the code
Step 3: Updating the MySQL record if user not paid (Atomic transaction)

What will happen if at Step 2, one more request comes to cancel the payment, and then that query runs first and marks user as free, then step 3 runs and user marked as Paid.

🕺🏻 Hurray, User got access to our Products without even paying.

Locking

✅ Here comes the saviour, Locks

🔐 Lock is a structure that allows only one thread at a time to enter a critical section (block of code that should not be accessed by multiple workers i.e. threads)

Hence, we will acquire lock before and release after the completion of the operation:-

Step 0: try-acquire() lock
Step 1: If acquired, We are fetching user (Atomic transaction)
Step 2: Running some business logic in the code
Step 3: Updating the MySQL record if user not paid (Atomic transaction)
Step 4: release() the lock

😅 Problem

Now, here comes the problem which is if we will use some in memory lock data structure or any memory based lock it will be eligible for one instance for our application. what about the other instances running the same code and updating in the DB?

Well here comes the concept of Distributed locking

🔓 Distributed Locking

Here lock acts as a centralised service, where if one instance of our service acquires the lock then others can't on the same key.

WHAT KEY COULD BE HERE IN PAYMENT SERVICE?

🔓 For a user making payment key could be the combination of = "PAYMENT_" + user_id + amount

And this will be unique per user. And this key will remain same in case of user making payment or cancelling payment. Hence when one is happening other action can't proceed because both actions will try to acquire on same key.

💭 What what the heck is Key, Acquire lock, release lock. And most importantly how redis is being in use?

🎈 Using Redis to implement Distributed Locking

Using a single instance of Redis:-

But here are the few problems with a single redis instance:-

A single instance may fail & lock acquired may not be released
If two instances are used (master-replica) when one client will acquire lock on one instance
master has to communicate the same with replica to sync. This communication itself is an async communication

🚀 So, if lock is acquired on master, and while communication to replica if master goes down before syncing with replica. Replica will become master where Lock on the same key will be available to acquire that was acquired on the master earlier.

Two instances of our services will be able to acquire the lock on redis even having two instances (master-replica).

Using Redlock Algorithm:-

Acquiring Lock:- We will try to acquire lock on multiple redis instances with lock expiration time
Validation of Lock:- lock will be considered as acquired if major redis instances got lock acquired for the client
Releasing Lock:- When releasing the lock, all instances releases the lock

And yes that's it.

❤️ Thanks for the read, and subscribe to our newsletter for more such articles:- https://www.serversidedigest.com/

For more information:-

Jedis in Java:- https://redis.io/docs/latest/develop/connect/clients/java/jedis/
Redis Client in Golang:- https://github.com/redis/go-redis

Multithreading: Event Loops vs Thread Pools and more...

SinghDevHub — Fri, 15 Dec 2023 09:35:30 +0000

😩 Whenever we think of running a program we always focus on running the code but we do not care about who is running the code.

Do you know who runs the code, who carries the program to the RAM and how it executes?

😎 So, There is something called Thread. Who is responsible to run your program/code by using main memory (RAM), CPU and storage or in general our machine's resources.

Threads are nothing but a worker who has Thread block, stack and access to heap.

But what the heck is stack, heap and Thread block?

📌 Stacks, Heaps, Thread Blocks

Whenever you write a function

def add(a, b):
   return a+b

Then, when we'll run this code we will declare the function in our main memory (RAM) and a pointer to this function will be stored in the stack.

Img Ref:- Link

✨ So, stack is a scope level memory space where your variables like a and b (Local variables) will be stored and heap is a dynamic memory where the pointers, dynamic arrays and objects (instances of classes) gets stored.

📌 Stack gets cleared when a function's executions gets completed like it will be flushed but heap requires a manual cleaning in some programming languages and in some we have garbage collection.

Don't worry, follow along you'll get for sure, and please like and save the article to support us

😎 Now, we know stack, heap which is used to store on the go things when your program runs.

But what about our man who carries whole stuff?? Thread right.

So, thread has thread block

So, thread block has some fields and a kind of storage unit only which has some info to run a program and access some shared space or its own space. Shared space is heap memory space and its own space is stack.

💀 Now, comes the part what is an Event Loop and Thread pool.

When someone works in Javascript he/she might have known that JavaScript is a single threaded language which simply means is that whatever your code is it will be carried by a single worker.

But if someone is working in Java, C, C++ etc there we have multiple threads that can be used in parallel.

Have some patience guys, you will understand 💯

📌 Multithreading

Now, let's say you have two functions (in JAVA)

class Main{

public void static main(String[] args){
     System.out.println("Hello world");
}

public static void add(int a, int b){
     System.out.println(a+b);
}

public static void substract(int a, int b){
     System.out.println(a-b);
}

}

😎 Now, Thread 1 can carry add() function and start its execution and Thread 2 can carry substract() function and start its execution right? Because both are independent.

So, there is something called context switching. It is like if Thread 1 is let's say is waiting for some user's input then Thread 2 will be running and context will be shifted from Thread 1 to 2.

😎 Current state of Thread 1 will be stored in its block and Thread 2 will continue its running. The main aim of Multithreading is to make sure CPU is not going in idle phase. It should be continuously in use.

😩 But in Javascript we only have Thread 1, How we can parallelize the things there.

🫶 Here we have the Event Loop.

📌 Event Loop vs Thread Pools

Now let's say the code in JS is like:-


function add(){
    setTimeout(()->{
         console.log("I am lazy");
    }, 1000);
    console.log("I am active");
}

Here we can see there is one block who is waiting for 1000ms (1sec) and after that it will run. But there are other code lines which are independent and can run meanwhile. So,

setTimeout(()->{
         console.log("I am lazy");
    }, 1000);

can go in waiting phase and meanwhile

console.log("I am active");

can run. So, setTimeout() will go in eventLoop and it will wait for the sync code to run. And this waiting code is async code.

Img ref:- Link

❤️ Here, event loop will keep looping and checking if there is any program to run in the callback queue (in this queue async code will come). After all the sync code completion (when stack of sync code gets empty) async code will run.

😩 It is a kind of Blocking thing right? what if sync code get's into infinite loop then all the async code will stop right? Yes. that is the problem, that is why timeouts needs to be configured carefully.

Now, coming to the threadpools:-

🥹 Now the question comes is, when we read a Big file and make it async and how does than other sync code runs if the async code is also suppose to run in the future.

Here is where we have Thread Pools. Like, To read a file you will do this

let filePath = "test.txt";
let fileContent = fs.readFile(filePath, "utf-8", (data, err)->{
    return data;
})

Now, our OS has threads and Javascript will give the work to read the file to one of the thread from the thread pools of our OS and our OS has some system calls which it will use to read the files and will save to a buffer.

This buffer will be in memory only

byte[] buff;

and there is a callback function

(data, err)->{
    return data;
}

which will be called once the file read is completed. and then Javascript main thread will copy content from the buff[] to data