C on Siddharth Mishra

A C Of Polymorphism Without CPP

Wed, 25 Mar 2026 00:00:00 +0000

Introduction

Polymorphism sounds like a C++ word. In C, it still exists, just without the sugar. You create a base type, keep a table of function pointers, and pass that base pointer around.

A Small Example

Here’s an example. This is the base class.

typedef struct Animal Animal;

struct Animal {
 char* name;
 void (*speak)(Animal* self);
};

Now the child types.

typedef struct {
 Animal base;
} Dog;

typedef struct {
 Animal base;
} Cat;

The polymorphic functions live in the child types. There is no default animal_speak(), so this behaves like a pure virtual method.

OnlyGenerics In C

Wed, 25 Mar 2026 00:00:00 +0000

Introduction

C doesn’t have templates, but it does have the preprocessor. If you’re careful, you can get something that feels like std::vector<T> without switching languages. It’s not perfect and it’s not type theory, but it is surprisingly usable.

This post is about that: cheap macro tricks that give you “templated” types in plain C.

The Core Trick

You first define a generic backing struct. Then you create a macro that expands to a type‑specific struct. That macro is your “template”.

A Build System For C in C

Wed, 29 Jan 2025 00:00:00 +0000

I recently started a new project where I had to decide (again) how to build this project. This decision is faced by any developer who use a language that does not have a standard way of building things. In my case, my project is to be written in C, my go-to language, and as we all know, it does not have any standard other than the standard spec. I usually go with CMake, as my go-to build system, because I’ve seen many projects use it. It’s almost like the “industry” standard. It’s very old, and regularly updated, to keep itself up to date with available libraries, frameworks, compiler features etc… and it might be good for very big projects, but I decided that I’ll try something simpler this time.

AutoGrad - Algorithmic Differentiation in C

Sat, 28 Dec 2024 00:00:00 +0000

Background

Let’s write an auto differentiation algorithm. We will take mathematical expressions in prefix notation, build an expression tree like the one below for

\[ \begin{align} 1338 * a + \frac{y^5}{x^{1335}} \end{align} \]

// expression in prefix notation
Expr e = ADD_EXPR(
 MUL_EXPR(INT_CONSTANT_EXPR(1338), VAR_EXPR("a", 1)),
 DIV_EXPR(VAR_EXPR("y", 5), VAR_EXPR("x", 1337))
);

graph TD
 node0["add"]
 node1["mul"]
 node2["1338"]
 node3["$a^{1}$"]
 node4["div"]
 node5["$y^{5}$"]
 node6["$x^{1337}$"]

 node0 --> node1
 node0 --> node4
 node1 --> node2
 node1 --> node3
 node4 --> node5
 node4 --> node6

and then write an algorithm to traverse the expression tree, taking derivatives of each sub-expression recursively and then generating a new expression tree that represents the derivative of the original expression tree, like the one below by just doing ExprGrad(&e)

Zero To Prod In C - Creating Server & Hosting

Wed, 25 Dec 2024 00:00:00 +0000

Background

I recently started looking into self-hosting, and after spending two almost sleepless nights, I finally have a solution to self host any service and link it to an endpoint with your domain name. Usually, you’d need a static IP address that you must purchase from your ISP, and it’s quite costly (depending on bandwith and IP range). This solution does not need any static IP address, or port forwarding or any magic from your side. You just need a machine where you can just do things. In my case I have a Raspberry Pi, on which I’ve installed Ubuntu Server, but this can be any machine that you can keep up for extended periods of time, be it your laptop, or a real home lab setup, everything goes.

How I Do Error Handling in C

Fri, 13 Dec 2024 00:00:00 +0000

This is not actually supposed to be a post because I think everyone has their own way of doing things. This post I’m writing is just to overcome the FOMO of not writing enough blog posts, but owning a domain and constantly keeping up my Pi4 to host this static website. Also because good software engineers recommend making a habit of writing a blog post regularly.

The Problem

You’re writing lots of functions in your program and it’s possible for those functions to fail and you want to know when they fail. Say you’re creating a Vector implementation in C and you want to know whether the VectorPushBack method you wrote will fail or succeed in inserting element.

Creating Our Own 'puts'

Sun, 09 Jan 2022 00:00:00 +0000

Well, the title can be misleading. We will be eventually implementing our own ‘puts’ function but for now it’s not named puts. The function will be analogous to puts. This function will actually be to help us debug things. After this chapter we will be adding more and more features to our OS and we need a method to see if it worked or not. This method can be anything! For eg : changing the screen colour to red (for error) or blue (for success). We print an error message if something bad happens.

Project Initialisation

Sat, 08 Jan 2022 00:00:00 +0000

We’ll use limine bootloader and use stivale2 as our boot protocol. There are multiple boot protocols and stivale2 provides many advanced features. Limine supports stivale2 by default. It also gives us a way to instantly print anything on screen but we won’t be using that. To read more about stivale2 boot specification, read here

Create project with following directory structure

.
├── CMakeLists.txt
├── kernel
│   ├── kernel.c
│   ├── kernel.h
│   └── stivale2.h
└── limine
 ├── bochsrc
 ├── build-aux
.
.
.

19 directories, 183 files

kernel will contain our kernel code. Soon we’ll be creating many other folders. Use wget to get stivale2 header file. Initialise a git repository and add limine boot loader as a submodule.