DEV Community: sanskar arora

☠️ HomeLab Chronicles: Bash, Bootloaders and BooBoos

sanskar arora — Sun, 08 Jun 2025 15:20:53 +0000

Ahoy, me nerdy hearties! ⚓

Today, we sail deeper into the digital abyss, where the seas are encrypted and the only map we follow is man pages. Welcome to Part 1 of this chaos: Getting Arch Installed & Ready for SSH Shenanigans. 🧑‍✈️💻

Let the plundering begin.

🪓 Step 1: Flashin’ Be Plunderin’

Get yerself a fresh Arch ISO (ye ol’ treasure map 🗺️) and flash it onto a thumb drive. Use whatever tool ye fancy — dd, balenaEtcher, or magic. Doesn’t matter. Just don’t accidentally nuke your primary drive or the Kraken (a.k.a. your data) shall rise.

⚰️ Step 2: Boot Ye Olde Rig

Plug in yer USB, boot that dusty Dell (or whatever sea-worn vessel ye got), and sail straight into the BIOS. Change boot order like a rebellious pirate ignoring port law, and let the Arch ISO take the wheel. 🚢

📡 Step 3: Cast the Wi-Fi Net

Time to connect to the seven signals. Enter the iwctl tavern and speak these sacred incantations:

iwctl
station wlan0 scan
station wlan0 get-networks
station wlan0 connect wifi_name
station wlan0 show

Once you're connected, exit like a ghost (exit), and if you’re the suspicious type (which you should be), test your signal with ping archlinux.org -c 3, if the ping pings, the wind is in our sails. 🌬️🏴‍☠️

🔐 Step 4: SSH or Walk the Plank

Install OpenSSH (if it’s not already on board — usually is) pacman -S openssh.
Set a password for the root user (yes, ye be root now — absolute pirate king 🧑‍✈️). Let’s say: passwd choose something like "pass" if you're feeling lucky 🍀.

Now SSH into the box from yer main ship:

ssh root@<ip_address>

If your OS barks at ye, find an equivalent command or walk the plank.

🪚 Step 5: Slicing Up the Drive Like a Mango

Time to swashbuckle that drive:

/boot — 1GB ⚓
EFI — 1GB 🧭
The rest? LVM party time. (But don’t forget to save a few gigs for future chaos.) Estimated ~125GB for LVM. ⚔️

We use the old-school blade: fdisk. Because real pirates don’t use fancy new TUIs.
We're encrypting the big LVM partition, not the little ones — because we hate pain, but not that much.

🧙 Step 6: Manual Install? Aye, Because Pain is the Best Teacher

Could we run archinstall and be done? Sure.
Do we want to? HA. No. Where’s the fun in that, matey?
We do this the hard way. Because learning builds character (and for once, not craving trauma).

🔗 Important Runes (You Will Forget Otherwise)

Trust me, sailor, these are hard-earned battle scars:

🔩 Load Device Mapper before formatting yer volumes:

  modprobe dm_mod

🪛 Update mkinitcpio hooks (or prepare to scream): In /etc/mkinitcpio.conf, modify:

  HOOKS=(base udev autodetect ... encrypt lvm2 filesystems)

⚙️ Tweak GRUB so it speaks encryption: In /etc/default/grub, update:

  GRUB_CMDLINE_LINUX_DEFAULT="... cryptdevice=/dev/<drive>:<volgroup> ..."

💣 MOST IMPORTANT: Generate that GRUB config or the boot gods shall smite you:

  grub-mkconfig -o /boot/grub/grub.cfg

If you skip this, your bootloader will throw a tantrum and “not find vmlinuz or initrd,” and you’ll be mounting USBs like a panicked sailor chasing his lost rum barrel.

(Yes, I did that. Yes, it sucked. Yes, I survived. Barely. 🥲)

🐳 What’s Next?

Now, Arch is alive and answering pings like a loyal parrot, we’ll move on to the Big Fish™: setting up Kubernetes.

But for now… pour yourself a drink, pat your encrypted SSD, and take pride. You’ve sailed through the cursed waters of manual Arch install. 🍻💾

Until next time, mateys.
Keep your drives encrypted and your SSH keys close.

And remember, the name is Captain Jack Sparrow 🏴‍☠️

EDIT (a day later)

Today, while on the bus, I had a thought, To kubernetes I need at least two runners - 1 master and 1 worker node, and guess what, I only have 1 system to experiment with.
I have three options:

buy another machine (Too expensive)
setup a virtualisation solution to get around it (Considering Proxmox and HyperV for now, could move to another hypervisor as well)
hybrid setup - with master node on my machine and workers on VMS in cloud (Azure/GCP)

I am going ahead with option 2 (Hypervisor) because option 1 is expensive, and option 3 will have too many components, and if something goes wrong, there would be multiple points to check on (n/w concerns me the most). So, for now, I will start with hypervisors and then, after successful deployments and testing on my assembled cluster, probably include hybrid nodes (Azure, GCP, etc).

🏠 HomeLab Chronicles: Episode 1 - Arch-nemesis

sanskar arora — Sat, 07 Jun 2025 21:26:41 +0000

Hey all 👋

So, I was supposed to be working on my garbage collector project and the very stoppable StopLang, but... you know when your brain says C, and your heart screams "Sea ya later!"? Yeah. That.

So instead, I’m kicking off a new project and a new series I’m calling:

🧪 HomeLab: Because what's better than chaos in your own home?

💻 The Plan: Frankensteining an Old Laptop

The victim: a brave old Dell Inspiron 🧟‍♂️
Specs:

CPU: 8thgen i5 processor (not the freshest fruit in the basket, but it'll do)
Memory: 8GB of dreams
Disk Space: 256GB of potential

I’m going to torch this machine 🔥 with a Linux distro (no GUI, because who needs fancy pixels?) and then just vibe with it.

🏴‍☠️ Why Arch? Because I hate myself (but in a fun way)

Arch Linux is my pick for this culinary disaster of a home server. Here's why:

No bloatware. Just vibes.
Comes bare minimum out of the box (just like me on Mondays).
Most importantly, PewDiePie uses Arch.
- And honestly, it bruised my tech ego that while I’m here running Ubuntu, he’s flexing with Arch. Not okay.

🧠 Backstory:
I was actually an Arch user until November 2024 (RIP). Then I got a shiny new laptop and realized I no longer had the time (or sanity) to fix bootloader issues for the 100th time or recompile audio drivers like it’s Groundhog Day. So I reluctantly joined the Ubuntu™ Easy Life Gang.

🏗️ The Mission: Milestone 1

Here’s what I’ll be doing in Phase 1 of this HomeLab Madness™:

✅ Step 1: Install Arch (with just enough to not regret it instantly)

Barebones setup only. Think minimal. Think IKEA flat-pack with no manual.

✅ Step 2: Remote Control, Baby 🚀

Get remote SSH access, because reaching across the room is so 2020.

✅ Step 3: K8s or Bust 🐳

Set up a Kubernetes cluster from scratch.
- No kubeadm, no fancy tools.
- Just pure, uncut YAML & CLI pain.
- Because apparently I like suffering.

✅ Step 4: 🔥 Wall Building (Digital Only)

Set up firewalls to protect this digital potato.
But I want more than just ufw incantations — I’ll aim to build something slightly more usable, because who wants to memorize commands when you can just push a button?

🚀 After That?

Big plans, my friends.

I’ll be building a platform where I can deploy workloads on this cluster using:

A Docker image URL (or a local name if I’m feeling nostalgic),
A few config options to tweak runtime behaviour & exposure,
And some classification magic to keep things sorted.

Basically: "Give me a container, and I shall give it a home."

💬 Final Thoughts

This series is going to be weird, wild, and probably involve more swearing at YAML than anyone should legally be allowed to do. But hey — that’s (I guess) the HomeLab life.

Stay tuned, grab popcorn 🍿, and wish my Dell laptop luck. It’s going to need it.

Birth of StopLang – A Useless Language With a Very Specific Purpose

sanskar arora — Thu, 05 Jun 2025 19:49:32 +0000

So, I wanted to implement a garbage collector.

Cool idea, right? Memory management, pointer wizardry, existential dread—the whole buffet.

But then came the realization™️:

“Uhhh, how the hell do I even test this thing?”

You can’t really test a garbage collector in a vacuum (though that would collect garbage nicely). I needed some code, some variables, some actual garbage. Something to allocate memory, throw things around, and see if the collector actually does its job—or rage quits.

Option A: Plug it into an existing language

Like a real adult. Take some interpreter written in C, rip out its memory management, and bolt mine in.

But nah.

That way lies integration hell.

Do I look like someone who enjoys linker errors and segfaults from code I didn’t write? (No. No, I do not.)

Option B: Just build my own language

Like an unhinged adult.

So that’s what I did.

Okay so here’s the tea:

🛠️ It’ll be compiled, because I want my errors during dev time, not as jump scares during runtime.
⚙️ It’s in C, because:
- C++ is too friendly (a little too comfy, not enough pain).
- Assembly is too sadistic (I still like my sanity).
- C is that spicy sweet spot of power and pain.

We're going full DIY on this one. Think of it as a language that’s just smart enough to test our GC, but dumb enough that we don’t have to spend years writing a parser.

Now, we needed a name. Something iconic. Something that tells you what this language is really about.

And so, I give you:

🛑 `StopLang`

Because:

It’s the opposite of Go. It doesn’t want to “go” anywhere.
It’s useless, and proudly so.

It’s not fast.

It’s not smart.

It’s barely a language.

But it’s ours, and it will be just good enough to build and test garbage collectors.

Bonus: It will be easier to read than Brainfuck, and more coherent than Brainrot. (Which honestly sounds like medical conditions at this point.)

📌 What’s Coming Next?

This blog would turn into a research paper if I tried to cover everything here. So we’re breaking it down:

This post: Why StopLang exists and how I got here (hello chaos)
Next post(s): Building the core of StopLang—basic syntax, data structures, compiler setup, maybe a sad little REPL
Then: Plugging in our garbage collectors and watching them either work… or work once and then segfault spectacularly

If you’ve read this far, bless your soul.

Thanks for bearing with the puns, the rambling, and the “what if I just wrote a language for no reason?” energy.

Stay tuned, fellow code gremlins.

More nonsense incoming soon. 😈🧹

Building a Garbage Collector in C: Because Who Needs Sleep Anyway?

sanskar arora — Mon, 02 Jun 2025 22:12:34 +0000

Let’s be honest: most people’s idea of a good time doesn’t involve poking around in the underbelly of C, trying to make memory management less… well, terrifying. But here I am, rolling up my sleeves and diving into the world of garbage collectors. Why? Because understanding how the engine works under the bonnet is way more fun than actually driving the car. (And also, I’m only a little cracked—not batshit crazy, so no assembly for now.)

Why C? Why Not?

You might ask, “Why C? Why not something friendlier, like Python, or at least C++ with its fancy destructors?” Well, I want to keep things low-level. Real low. Like, “I can see the bits and bytes from here” low. Plus, C gives you the delightful opportunity to shoot yourself in the foot with malloc and free, which is basically a rite of passage for any programmer.

Step 1: Accept Your Fate

Before you even write a line of code, accept that you will spend hours debugging segfaults, chasing dangling pointers, and questioning your life choices. This is normal. This is growth. This is C.

Step 2: Plan Your Collector

There are many flavours of garbage collectors—reference counting, mark-and-sweep, generational… I’ll probably start with something simple, like reference counting and end with mark-and-sweep, because I like the idea of pretending to be a janitor for my code. (“Sweep the heap, Daniel-san!”) And yes, I am only going to do 2 types.

Step 3: Write Some Code, Break Some Code

Here’s where the real fun begins. You’ll write a function to allocate memory, another to mark what’s still in use, and a third to sweep away the rest. Inevitably, you’ll forget to mark something, and your program will crash spectacularly. Don’t worry—it’s all part of the process.

Step 4: Document the Madness

As I go, I’ll document every step, every bug, and every existential crisis. Because if you can’t laugh at your own memory leaks, what can you laugh at?

The Journey Continues…

So, join me as I attempt to tame the wild beast that is manual memory management in C. Will I succeed? Will I lose my mind? Will I finally understand how the engine works beneath the bonnet? Only time—and a lot of printf debugging—will tell.

Stay tuned, and remember: in C, the real garbage collector… is you.