DEV Community: csm

10 problems I face to start a new project!

csm — Sat, 31 Oct 2026 08:08:45 +0000

I will just go straight into the points (sorry, problems):

1. Idea

My mind is really good at not giving ideas and occasionally giving some cool ones
Some thing that I saw somewhere looks cool, but feels not in my range.
Some thing that I can implement and is simple and fun but feels waste of time.

2. Fear that someone else already implemented it or is doing it better than me

The feeling comes like I need to build the best thing in the world or else am done!

3. Naming the project!

This is where all my energy goes! 😂
Either the name is not cool or the name conflicts with an existing one.

4. Choosing Tech Stack

I know that practical choices should be made but my mind fights with:
cool new niche tech stack vs industry standard vs bla bla bla

5. Scope of the project

The focus should be on MVP but mind goes for tiny little unncessary details.

6. Project setup

The idea, the motivation all dries up before I even finish the setup!

7. Git commit messages

I did my setup commit like 'project setup'
Then I remember the already commit made by github is 'Initial commit'
Its starting with capital letter, but I like all small letters.
But, wait I also like consistency!

After some commits:
Should I make a single commit for all the changes I just made or multiple commits: one for a feature, one for updating README, one for updating my name in License.

8. Code organisation and conventions

camelCase vs snake_case vs PascalCase
output folder name: target vs build vs bin vs ...
exposing all the contents of a pkg vs explicit one thing

9. Writing tests

Still I don't like testing and I don't know how to write tests!

10. Half of the project is done and my mind getting distracted by another cool project!

Its fully because of laziness!

Conclusion

Its just a post to yell at my habits to feel light!

I read some articles related to this topic and got inspired to carefully observe what my problems are and note them down!

mc- A pre-preprocessor for C for header files generation

csm — Fri, 30 Oct 2026 10:56:59 +0000

mc

mc stands for meta-c:
A pre-preprocessor for C.

It generates .h header files for .c files using custom macro syntax.

link to repo

Disclaimer

With mixed feelings of guilt and pride, I want to say that this is a purely vibe-coded app.
But it works exactly the way I wanted it to.

Why

In C, as a beginner, its difficult to keep switching between a .c file and its corresponding .h file just to update declarations. mc solves my problem.

I got the idea from Pascal, where you can write the implementation and interface in the same file.

Why the comments as macros

Its because,by using comments as macros, code editors don't need a new language extension to recognise plain regular c code.
Best of both worlds.

Development Environment

Operating System: Linux Mint
Go Toolchain

Example

The idea is:
In a single .c file using custom comment macro syntax we write all our .h header content and give the file to mc and it will generate the header file.

hello.c:

// Hello module example!

//@pub
void hello();
//@end

#include<stdio.h>

void hello(){
    puts("Hello world!");
}

main.c:

// Enven if empty each .c file should have the @pub macro at the top
//@pub
//@end

#include "hello.h"

int main(){
    hello();
    return 0;
}

MC Rules

Each .c file should have @pub macro at the top.
Before @pub macro whitespace characters and single line comments are allowed.
@pub macro can be empty.
Anything inside (between the macro comments //@pub //@end will go to the .h header file).
Every generated header file template includes #pragma once at the top, even if the @pub macro is empty.

Commands

mc <no args>      -> Print mc version and help
mc -version,  -v  -> Print mc version
mc -help,     -h  -> Print mc commands list
mc -watch,    -w  -> Watch for any file changes and regenerate .h files
mc hi.c main.c    -> Generate .h header files in include/ folder for given .c files

License

MIT

sz - view file size

csm — Sun, 18 Oct 2026 08:07:41 +0000

sz

A Linux utility for viewing file sizes.

link to repo

Overview

sz displays the size of a given file in human readable format (KB,MB,GB).

Example:

sz hello.txt

4.50 MB

Development Environment

Operating System: Linux Mint
Rust Toolchain

Building the Project

clone the repo
cd into the cloned repo
to build:

cargo build --release

the sz binary will be created under "target/release" folder.
Add the sz binary's directory to PATH to use it from anywhere in the terminal.

Commands

sz <no args>     -> Print sz commands
sz -version, -v  -> Print sz version
sz -help,    -h  -> Print sz commands
sz <file.txt>    -> Print file size

License

MIT

trailing return types in cpp

csm — Wed, 14 Oct 2026 07:13:29 +0000

I know that C++ has different versions (standards) and
and from C++11 its called modern C++, because it got many features that made C++ feel like a brand new language or simply modern.

And it did all this while maintaining backward compatibility!
Still, there are many things people don't like about C++.
For me, especially the lengthy return types that hide the function names.

For example, suppose you have a function like this:

std::tuple<std::vector<Diagnostic>, std::vector<std::string>,
           std::unordered_map<std::string, std::string>,
           std::unordered_map<std::string, std::string>>
parse(std::vector<std::string> &args){}

😅 Can you see where the function name is?

I've always wanted a feature like the one in modern languages such as Rust and Go, where you write the return type after the function's parameters.

Guess what? All this time, I didn't know C++ had supported trailing return type syntax since C++11!

Now the same above function, using trailing return types, would look like this:

auto parse(std::vector<std::string> &args) -> std::tuple<
    std::vector<Diagnostic>, 
    std::vector<std::string>,
    std::unordered_map<std::string, std::string>,
    std::unordered_map<std::string, std::string>
> {
    // Function body
}

Conclusion

It has happened many times that C++ already had the features I needed. I just didn't know they existed!

whoami in rust

csm — Wed, 07 Oct 2026 02:57:41 +0000

whoami

A reimplementation of the Linux command whoami in Rust.

link to repo

Overview

whoami displays the user name associated with the current effective user ID. Same as id -un.

Example:

whoami

csm

Development Environment

Operating System: Linux Mint
Rust Toolchain

Building the Project

clone the repo
cd into the cloned repo
to build:

cargo build --release

to build and run:

cargo run -- -help

Commands

whoami <no args>     -> Print effective userid
whoami -version, -v  -> Print whoami version
whoami -help,    -h  -> Print whoami commands

License

MIT

What I learned?

Simple command does not mean simple to implement
For the first time wrote some unsafe rust code with libc crate.

Programming kya hai?

csm — Sun, 04 Oct 2026 02:06:54 +0000

Yaha tak aane ke baad, ye title thoda ajeeb lagega 😅
Par ant tak bane rahiye!

Programming kya hai?

Sabko pata hai:
aagyakaari computer ko aagya dena!

Computer ki bhasha kya hai?

Computer sirf binary, yani 0 aur 1, samajhta hai.

Programming language kya hai? Aur itni saari kyun hain? 😭

Jese hum insaanon ki bhasha sirf sound hai, wese hi computer ki bhasha sirf electricity voltage level hai.

Higher voltage -> 1
Lower voltage -> 0

Ab hum sound ko likh nahi sakte, isliye humne script banayi hai. Kuch usi tarah, humne assembly language banayi hai!

Assembly bhasha machine bhasha ke bahut nazdeek hai, isliye mushkil hai:

; Linux x86-64 with NASM
section .data
    msg db "Hello, World!", 10
    len equ $ - msg

section .text
    global _start

_start:
    mov rax, 1          ; sys_write
    mov rdi, 1          ; stdout
    mov rsi, msg        ; message
    mov rdx, len        ; length
    syscall

    mov rax, 60         ; sys_exit
    xor rdi, rdi        ; exit code 0
    syscall

Tabhi humne high-level languages banayi hain, taaki program likhna aasaan ho.
Jese: C, C++, Rust, Go, Python, JavaScript, aadi.

Programming languages kitne tarah ke hote hain?

Compiled (C,C++,Rust,Go)
Interpreted (Python, Ruby)

Compiled yani hamara likha hua code, binary me badal kar ek file me save karte hain.
Wo file seedha hum chala sakte hain.

Jese, packed food items ki tarah, seedha kha sakte hain.

Interpreted matlab jab hum kahenge, tab us waqt interpreter hamare likhe code ko line by line badal kar chalayega.

Jese, garam-garam dosa hotel me banakar dete hain, aur hum wahi par khaate hain.

Hello World Program

To, hum kaha par the?

Go me Hello World Program:

package main

import "fmt"

func main(){
    fmt.Println("Pranaam 🙏🙏🙏🙏")
}

Humne ab tak seekha hai ki har Go program me ek main package hoga, jisme main function se hamara program shuru hoga.

Yaha par sirf ek line hai main function ke andar, jo "Pranaam 🙏🙏🙏🙏" ko print karegi.

fmt ek package hai jo Go ke saath aata hai, jismein Println() ek function hai, jiska kaam text ko terminal par print karna hai.

fmt package standard library ka hissa hai.

Kya hum bina library ke code likh sakte hain?

Jo students beginners hain, unmein kuch logon ko ye bhram hai ki agar hum bina kisi library ki madad ke saara code likhenge, tabhi hum programmer ya developer banenge.

Par ek udaharan ke saath is bhram ko door karte hain:

Hamare ghar ek baar ek carpenter uncle aaye the door lagane ke liye.
Wo sirf bana-banaya door lagate hain.
Door humein hi kisi dukaan se khareedna padta hai.

Lekin purane zamaane me carpenter khud ghar aakar wahin par lakdi kaat kar door banate the aur phir fit karte the.

Is zamaane me na hamare paas waqt hai, na paise, door banwa kar lagwane ke liye.

To jo uncle hamare ghar aaye the, wo bhi carpenter hain, aur jo shop me door banate hain, wo bhi carpenter hain.
Bas unka kaam alag hai.

Waise hi, Python me code likhne wale bhi programmer hain aur Python ki libraries likhne wale bhi programmer hain.

Jis domain me humein ruchi ho, usi me jaana chahiye!

Aaj ke liye bas itna hi 🫡

Kavi: Ab waqt hai meri all-time favorite kavita ke liye!
Sunna chahoge?
Shrota: Bilkul!
Kavi: Arz kiya hai,

हार को चुराने से चोर बनोगे

Shrota: Thik hai thik hai, aage?
Kavi:

और हार को हराने से वीर बनोगे

Shrota: 🥶

pwd in rust

csm — Fri, 02 Oct 2026 05:29:38 +0000

A reimplementation of the Linux command pwd (Print Working Directory) in Rust.

link to repo

Overview

pwd displays the full path of the directory you are currently in.

Example:

pwd

/home/csm/Documents

Development Environment

Operating System: Linux Mint
Rust Toolchain

Building the Project

clone the repo
cd into the cloned repo
to build:

cargo build --release

to build and run:

cargo run -- -help

Commands

    pwd <no args>        -> Print working directory logical path
    pwd -version,  -v    -> Print pwd version
    pwd -help,     -h    -> Print pwd commands list
    pwd -logical,  -l    -> Print working directory logical path
    pwd -physical, -p    -> Print working directory physical path (resolving sym-links)

License

MIT

Vim Basics

csm — Sat, 26 Sep 2026 02:21:08 +0000

Just the basics you need to get started.
Also for those who are trapped in classic vim situation, where you don't know how to quit!

Vim is a powerful, keyboard-driven command-line text editor (an improved version of the classic Unix “vi”) used for efficiently editing code and plain-text files.

Things you need

Linux Mint or Ubuntu
Vim 8.2 or above
Alacritty terminal (Why? Just for feel!)

Install

sudo apt update && sudo apt install vim

Open a file in Vim

Suppose you are inside a folder called hello and it has a file hello.txt.
You open the file in Vim:

vim hello.txt

Modes of Vim

In vim we have modes.
When you open a file the default mode is Normal mode.

Normal mode  -> Esc key
Insert mode  -> i
Command mode -> Esc key then :

What the heck are modes?

When you press 'i', you can type in the editor, thats Insert mode.
When you press 'Esc' key, you go back into Normal mode where you can view the file without typing.
When you press ':' inside normal mode, that is Command mode.

For beginners, insert mode is for you to type.
Later you will learn the powers of normal mode where you can use Vim's shortcuts to edit the file super hyper fastly!
Command mode, for now, is for saving the changes you made and to quit and get out of Vim.

Quit, Save, and others

First, press 'Esc' to ensure you are in Normal mode.
Then:

To just quit: Type :q then press Enter
To just save: Type :w then press Enter
To save and quit at once: Type :wq then press Enter
To quit without saving: Type :q! then press Enter

Example

1) Open the hello.txt file:

vim hello.txt

2) Type some text:

Press i
Then type this text:

hello world!

3) Save the changes:

Press Esc to come out of insert mode
Type :w and press Enter to save the changes

4) Quit:

Type :q and press Enter to quit

Classic 'Unable To Quit Vim' Situation

If you are someone who just want to quit, then:

Press Esc then type :q! then press Enter

Thats it! 🥶

GCC Flags Notes

csm — Fri, 11 Sep 2026 01:13:27 +0000

My notes on GNU C Compiler (GCC) Flags

Basic Flags

-c

It tells GCC to compile the source file into an object file (.o), but do not link it into an executable.

gcc -c main.c

This produces:

main.o

Then you can link it separately:

gcc main.o -o main

-o

It specifies the output filename.

gcc main.c -o main

We get:

main

-l

It means "link this library".
For example:

gcc main.c -lm -o main

Here:

-l -> link a library
m -> library name libm
-o main -> output executable named main

The library must be present in the standard search paths of GCC.

-I

It specifies an additional directory to search for header files.

gcc -Iinclude main.c -o main

This tells GCC:
When you see #include "something.h", also look inside the include/ directory.

-L

It specifies an additional directory to search for libraries during linking.
For example:

gcc main.c -L./lib -lmylib -o main

This means:

-L./lib -> search ./lib for libraries
-lmylib -> link libmylib
-o main -> produce main

-static

It tells the linker to create a statically linked executable.

gcc main.c -static -o main

Optimisation

-O

Sets the level of optimisation.

gcc -O2 main.c -o main

Optimisation Levels

0 -> does nothing
1 -> basic optimisation
2 -> produces small binaries
3 -> produces fast binaries (may not be small in size)

1 -> for fast compile times
2 -> for production
0 -> for debugging

Strict Rules, Warnings and Errors

Basic ones are:

-std

It specifies which C standard the compiler should follow.

gcc -std=c17 main.c -o main

-Wall

-Wextra

-Wpedantic

-Werror

Some extra ones:

-W

-Wconversion

-Wshadow

-Wcast-qual

-Wwrite-strings

Debugging Related

-g

It generates debugging information in the executable/object file.

gcc -g main.c -o main

It mainly tells GCC to include information that debuggers such as GDB can use.

Preprocessing Related

-E

It says run only the preprocessor.

gcc -E main.c

-D

It defines a macro from the commmand-line:

gcc -DTEST main.c

Here:

-D -> define macro
TEST -> name of the macro

Thats it! 😵‍💫

Pehla Go Program

csm — Sun, 26 Jul 2026 06:30:00 +0000

Pichle post mein humne Go ke baare mein jaana tha.
Ab Go ka setup karenge aur pehla Go program likhenge!

Pehle Magajmari (Setup)

Hame bas 2 cheese chahiye:

Ek Go
Dusra Code Editor

Official website pe jao aur apne platform ke hisaab se Go download kar lo.
Rahi code editor ki baat, to VS Code aur Go ka extension install kar lo.
Bas!

Chela: Guruji! Linux pe Go ka package kaha rakhna hai aur PATH environment variable kese set karte hai?
Guru: Baccha! Tu Go seekhne aya hai ya Google karna?
Chela: 😅 Bas iss baar bataado 🙏
Guru: Hmm.

Linux pe Go

Terminal kholo aur shuru ho jao!

Sabse pehle purna koyi Go installation ho to use uthake phenk do! Taaki version conflict naa ho.

sudo rm -rf /usr/local/go

Phir apne platform ke hisaab se package ko download karo (latest wala).

wget https://go.dev/dl/go1.26.5.linux-amd64.tar.gz

Ab us package ko unpack ya extract karo /usr/local/ me

sudo tar -C /usr/local -xzf go1.26.5.linux-amd64.tar.gz

Bas ab Go ka path set karna hai. Ye neeche wala command .bashrc file me Go ka path set kardega!

echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc

Ya to naya terminal tab kholo ya phir ye karo:

source ~/.bashrc

Ab Go ka version print karke dekho:

go version

Thoda Gyan

Kuch bhi likhne se pehle Go ke kuch niyam jaan lete hai!

Go ka code ham .go wale files me likhte hai (.go extension)

Ek example Go project ka structure kuch aesa dikhta hai

To, niyam:

Har .go wala file ek folder ka hissa hota hai jise ham package kehte hai
Jitne bhi hamare package wale folder hai wo sab ek bade folder ke hissa hai, jise ham module bolte hai
Ek Go module yaani ek project hai, matlab ya to module ko ek library ki tarah dusre projects me istemal kar sakte hai ya phir iss module se ek binary executable bana sakte hai
Ek folder ko module tabhi bolte hai jab usme go.mod file ho! Warna go compiler chillake bolega "Ye module nahi hai! Me compile kese karu?"

Yaha 2 sawaal manme ayenge:

go.mod file ka kaam kya hai?
Jab saare .go files kisi na kisi package folder ke ander honge to uper image me main.go file seedha module wale folder me kese ghum raha hai?

Aur unke javaab kuch ese hai:

go.mod file external dependencies ko manage karta hai. Yaani ki agar hamare project me ek web framework ya koi bhi library chahiye kisi dusre ka likha hua, to uska zikr hum go.mod file me karenge aur go compiler use project me add kar dega!
main.go, wese to uska naam kuch bhi rakh sakte hai par uske ander ham bolte hai ki ye main package ka hissa hai.
main package hamare module(project) ka entry point hai, jaha se execution shuru hota hai! Iss liye wo seedha module wale folder ke ander ghum sakta hai
Ek aur baat, ham jitne chahein utne .go files bana sakte hai main package ke ander, matlab module wale folder me!

Bas har file ke ander kehna hoga ki ye main package ka hissa hai, aur ek file esa hona chahiye jisme main() naam ka function ho!

Hello World Program

Terminal ko apne pasand ke location pe kholo aur shuru!

Project ka folder banake usme ghuso

mkdir hello && cd hello

Go se kaho ki wo go.mod file banaye

go mod init hello

Ab ek main.go file banao

touch main.go

main.go ko VS Code me kholo

code main.go

main.go ko neeche wale code se bhar do

package main

import "fmt"

func main(){
    fmt.Println("Pranaam 🙏🙏🙏🙏")
}

Ab file ko save karne ke baad wapis terminal me aake project ko run karo

go run .

Aapke terminal ke screen pe Pranaam 🙏🙏🙏🙏 wala message dikha to aapne sab tikh se kar diya!
Agar nahi dikha to kya karna hai mujhe nahi pata 😄
(Google karke dekhlo)

Iss program ka matlab kya hai ye hum agle post me dekhenge!
Tab tak ke liye alvida!

Golang in Hinglish

csm — Mon, 20 Jul 2026 18:42:23 +0000

A simple tutorial series on go in Hinglish.
Jitna mujhe aata hai utna, aur zyada tar mere notes se!

Note: Me non-native speaker hu to spelling mistakes to honge, is liye Hinglish spellings aur grammar ke liye main AI use karunga, par dev ke bot ko pata nahi chalega kyuki ye English nahi hai 😉

Parichay / Intro

Shuruat hum isse karenge ki Go kya hai aur uske fayde kya hain.

Pehle hum Wikipedia ki definition dekhte hain:

To, Go ek aasan language hai.

Go compiled language hai, matlab ek bar compiler ko humne apna code diya to wo ek executable file dega jo sidha hum chala sakte hain bina kisi aur dependency ke, jaise ki Python ka interpreter.
Dusri high-level languages jaise Python ya JavaScript se Go tez chalta hai.
Garbage collected hai, yani C ki tarah hame memory ko manually manage karna nahi padega.

Go ka istemal kahan hota hai?

APIs aur Web Servers banane me
Network Programming aur Distributed Systems me
Cloud-Native Applications aur Microservices banane me
DevOps aur Infrastructure Automation me
Command Line (CLI) Tools banane me

Agar upar ki baatein abhi samajh na aayein, to koi baat nahi. Filhal itna samajh lijiye ki Go ka istemal bahut jagah hota hai to job ke liye kaam aayega.

To ye thi Go ki kahani, CSM ki zubani... (jo chalti rahegi!)

Aur haan, har post ke aakhir me meri ek shayari hogi, jo aapko guru dakshina ke roop me jhelni padegi! 😄

ख़यालों को बातों में उलझाए रखना ।
इस पल के हक़ीक़त को सुलझाए रखना ।
शिद्दत से चाहा जो मिल कर रहेगा ।
चेहरे पे मुस्कान थोड़ी बनाए रखना ।।
-csm

TikTikBoom

csm — Sun, 14 Jun 2026 17:58:31 +0000

This is a submission for the June Solstice Game Jam

What I Built

Turing's Enigma: The Solstice Protocol (TikTikBoom) is a cyber-retro, pixel-powered architectural platformer and computer science puzzle-hacking game I built natively with React and the Phaser 3 Arcade Physics Engine.

Tasked with saving core system tapes from corruption, I designed a gameplay system where players journey deep into a simulated computing core at Bletchley Park. To progress, you must dynamically alternate your project's binary data states, intercept rogue runtime glitches, and override terminal arrays by solving logical computer science riddles.

My goal was to design an interactive experience that relates heavily to the Solstice timeline by directly celebrating the birthday of computing pioneer Alan Turing (born June 23rd). Rather than making a static quiz app, I integrated historical cryptographic components directly into an active, retro gameplay engine.

Live Game Link: https://tik-tik-boom-kappa.vercel.app/

Video Demo

Check out my video demonstration showcasing the system sequence, binary state-switching, and dynamic stage deconstruction loop in action:

https://youtu.be/YuTa3hB_7EU

Code

csm-18 / TikTikBoom

TikTikBoom

🌌 Turing's Enigma: The Solstice Protocol

A cyber-retro, pixel-powered architectural platformer and puzzle-hacking game built natively using React and the Phaser 3 Arcade Physics Engine.

Tasked with saving the core system tapes, you must journey deep into the architecture of Bletchley Park’s computing core, intercept runtime glitches, and break the shifting code logic patterns across 8 distinct architectural sectors.

Happy Birthday, Alan Turing! Built for the DEV June Solstice Game Jam.

🎮 Gameplay & Control Schematics

Navigate through security grids, manipulate the logic state of your data projectiles, and override terminal arrays.

Action Key	System Instruction Matrix
A / D	Move horizontal node left and right
W	Jump or scale architecture platforms
Z	Toggle binary code tape stream state between `[ 0 ]` (Cyan) and `[ 1 ]` (Orange)
SPACE	Fire targeted decryption code matrices
E	Interface directly with the physical Turing Bombe terminal mainframe

🔁 Core Loop Protocol

…

View on GitHub

How I Built It

I leveraged a hybrid configuration of modern web tech and hardware-accelerated graphics to assemble the engine:

React Wrapper Shell: I used React to manage the responsive layout viewport containment, game jam thematic branding, dynamic metadata panels, and interactive instructions.
Phaser 3 Physics Framework: I utilized Phaser to drive the 2D gameplay engine loops, platform collisions, player vector tracking, weapon projectiles, and sprite animations.
Dynamic Geometry Pipeline (buildLevelMap): Instead of using standard static level switching, I built a pipeline that completely wipes the canvas physics groups and procedurally constructs unique floor structures, target positions, variable enemy speeds, and distinct environmental colors across 8 progressive sectors.
Bi-Tier Operational Loop: I structured each level to follow a rigorous logic gate workflow. You first provide an answer to a Training Matrix conceptual problem (Arrays, Search Algorithms, Sorts, Linked Lists, Stacks, Queues, Binary Trees, and the Halting Problem). Correctly solving it releases binary color-coded glitch anomalies. Once purged, you return right back to the terminal mainframe to crack the Mission Matrix override and advance.
State Isolation Overhaul: I implemented safe-frame transaction locks (this.transitioning) and automated tactical instructional labels (this.phaseAlert). This allowed me to solve the critical UX blindspot of players getting disoriented during map transitions, cleanly guiding them when to fight anomalies and when to log back into the mainframe terminal.

Prize Category

I am officially submitting my game to the following category:

Best Ode to Alan Turing: The entire core narrative, timeline, mechanics, and architecture of my project serve as a tribute to Turing’s profound legacy. Players interface directly with a simulated Turing Bombe device, manage binary tape states, and run through a progression of fundamental algorithmic breakthroughs that he pioneered—culminating in breaking code blocks tied directly to the Turing Test and The Halting Problem.

Thanks

A huge thank you to the DEV team and the organizers of the June Solstice Game Jam!