Systems on AAYUSHYA

Big integer in Python

Thu, 02 Jul 2026 00:00:00 +0000

Today we are looking at how you can work with big integers in Python. What do I mean by “big” integers?

A standard 32-bit integer tops out at 2,147,483,647. A standard 64-bit integer tops out at about 9.2 × 10^18.

The very interesting thing about Python is: it doesn’t have a fixed ceiling for integers!

The only limitation is the machine’s memory. So you can effectively store any integer in a Python int.

Implementing mini Ollama from scratch

Fri, 15 May 2026 00:00:00 +0000

In my previous work, we discussed different ideas and ways in writing a server. To quickly recap, it’s writing it asychronously, writing a multi-threaded server or writing a “dumb” one. Each one has its pros and cons. People might say writing an async server would solve issues but it would not be the complete story. An async server helps when threads are idle waiting on I/O — network reads, file reads from external devices. Things like this, you can build an async server and it’ll get you the fastest latency. But they don’t provide us with the same improvements when the work is not I/O bound. Forge’s threads are idle waiting on compute — a different problem. We’ll see why in this article.

Writing an inference server in bare-metal C++

Wed, 06 May 2026 00:00:00 +0000

What is a Server?
It is a software program that manages resources over a network. The whole network could be visualized like this:

Today we are writing a server.

A dumb one, at first. We’ll benchmark the load handling of the server. And then we optimize.

Difference between websockets and a http server model WebSockets maintain a persistent, stateful connection where both client and server can continuously exchange data. In a traditional HTTP model, the client usually sends a request, receives a response, and the connection is then closed.

Studying threads and benchmarking python vs c++

Mon, 04 May 2026 00:00:00 +0000

Threads are the smallest unit of execution that an operating system can schedule inside a process.
People (me) get confused about what threads are and what processes are. This article will talk about threading as a programming concept and not the theory behind processes and threads. Nevertheless, we’ll talk about processes and threads too.

Processes and threads

Process A       
 ├── Thread 1       
 ├── Thread 2       
 └── Thread 3       

Process B       
 ├── Thread 1       
 └── Thread 2

Process is an independent program instance. It has its own memory and resources. Think of it like an agent.
A process can have one or more threads in it. Threads share the process memory and resources, though each thread has its own execution state and stack.
How processes and threads are implemented depends on specific programming languages and operating systems, so I highly recommend checking out the wiki.

Speeding up matrix math with SIMD intrinsics

Mon, 09 Feb 2026 00:00:00 +0000

Today we look at matrix multiplication (matmul, as we will call in this essay).
Since, the last essay was on backprop, it was only logical to think about the most fundamental math operation that lets us do the algo.
That is, matmul.
Also, the numbers in this essay are going to shock you.
Like really. So if you think I am making this up, you should checkout my code for this essay.

Implementing collision-resistant hash maps from scratch

Thu, 22 Jan 2026 00:00:00 +0000

what is this about?

Today we’re looking at hashing. We’ll get into the process, the data structures and some applications.

Through this article, we’ll see how we can implement dictionary operations, which are mainly:

insert
delete
search

what is Hashing?

Hashing is a technique of identifying an object out of a group of similar objects.

Analogy for hashing:
Imagine if you took your name tiwariji and ran it through a complex mathematical function that produced 7a3f9c2e. You couldn’t look at 7a3f9c2e and figure out it came from tiwariji, but every time you hash tiwariji you’d get the same result.

That, is hashing.

Ideally, no two different inputs should produce the same hash output. We’ll talk about that later when we discuss hash functions.

Memory layout: Stacks, heaps, and pointers

Fri, 16 Jan 2026 00:00:00 +0000

Data management during compiler process

When compiling a piece of code, the data in the code is stored in segments.

There are five types of segments:

stack
heap
data
code
BSS

We will focus on stack and heap in this essay.

Stack

Stack allocation is the process of allocating memory for local variables and function calls in call stack.
Each function gets some memory in the stack to store variables in it.
Since the memory is handled by the system, its faster. But the memory is less as compared to heaps.
The size required is already known before execution. The compiler allocates some memory.

How memory represents data at the bit level

Thu, 15 Jan 2026 00:00:00 +0000

Overview

When you call int x = 0; in your code, where and how is that x stored? This is the question that I wanted to know the answer of. And in this essay, we’ll look at just that. And

Why should you care?

As we will understand later in the article, there are issues and subtle bugs that come when programmers don’t understand their code. Hackers want to figure out ways to exploit those bugs and gain entery into people’s systems. So knowing how, why, and where of your data, in your system is not only useful, I’d say it’s necessary.

from code to execution

Sat, 03 Jan 2026 00:00:00 +0000

do you know how your code

int f(){
    return 42;
}

turns into

mov eax, 42
ret

and then into

B8 2A 00 00 00 C3

this?

Life would be very simple if we humans could write 1s and 0s and directly give machine it’s prefered machine code. But since we don’t have 1000 hands per person and the outputs that we’re expecting out of computers have evolved to complexities unimaginable, we need another simpler way to talk to the machines. And that is why we have different programming languages and their compilation processes.