Nnisarg's Blog

How to Improve Your Programming Skills (By Building Everything Yourself)

Mon, 06 Oct 2025 17:30:00 GMT

Most advice for developers focuses on speed - use this framework, that library, this new tool. But if your goal is to actually get better at programming, there's a simpler (and harder) rule to follow: build everything yourself.

Not because your version will be better - but because writing it forces you to understand what others skip. That's how you move from using tools to knowing them.

Why Building from Scratch Works

Libraries and frameworks hide complexity by design. They free you from decisions: routing, parsing, error handling, concurrency. That's powerful - but only when you already understand what's underneath.

When you re-create something yourself, you expose every assumption. You learn edge cases. You internalize design decisions. You build technical intuition.

As freeCodeCamp points out, abstraction is necessary - but too much abstraction, too early, can stunt your growth.

1. Build a Minimal HTTP Server

Skip frameworks. Open a TCP socket, read HTTP request bytes, parse headers, and respond.

What you learn:

How browsers and servers actually talk
Why status codes, headers, and content-length matter
How routing, sessions, and middleware evolved
What problems frameworks are solving for you

If you want inspiration, check out this short guide on writing an HTTP server from scratch in Python or this walk-through on building one in C.

Once you've built it - even imperfectly - frameworks like Flask, Express, or FastAPI stop feeling magical.

2. Write a Simple CLI Tool

Rebuild tools you use daily - grep, curl, ls, or wc. Don't use any libraries beyond the bare minimum.

You'll gain:

Argument parsing and flag handling
Input/output streams and file buffers
Error handling and exit codes
Modular code design and composability

These small utilities teach you to write clean, maintainable code. The Unix philosophy is all about simple, composable tools - rebuilding them helps that sink in.

3. Implement a Basic Encryption System (for Learning Only)

Don't use your own crypto in production. But implementing a simplified RSA or AES gives perspective.

You'll see:

Why randomness and padding matter
How key exchange is nontrivial
Why side-channel attacks and timing leaks exist
Why cryptography libraries are so careful with edge cases

If you want a practical starting point, read this short primer on implementing RSA in Python to understand the math behind it.

4. Build a Tiny Database

Start with a basic key-value store, then add persistence (write-ahead logs), indexing, and transaction support.

You'll learn:

Concurrency and locking
Durability and crash recovery
ACID properties
How indexing and query planning works

Build Your Own Database From Scratch is a great reference if you want to go deeper. Even a crude implementation changes how you view ORMs and SQL engines.

5. Design a Mini Framework

After you've built a few components manually, refactor by extracting routing, templating, and controllers. Create your own tiny "framework."

This teaches:

Abstraction boundaries
When to automate vs leave explicit
Dependency management
When abstraction is too much vs too little

You'll start recognizing the trade-offs frameworks make - and when they're worth it.

DO Re-Invent the Wheel - That's How You Master Programming

The point isn't to ship these projects. It's to understand why existing ones work. You'll write clunky code, hit dead ends, and break things - but that's the process that builds real technical depth.

Every library you use later will make sense because you've already built a rough version of it yourself.

How to Start

Pick one domain (networking, parsing, concurrency, storage) per month.
Build something minimal from scratch.
Write a short post about what broke and what you learned.
Link to references or comparisons.
Move to the next.

After a year, you'll have a library of real projects and a mindset most developers never reach.

You don't improve at programming by copying others - you improve by rebuilding what you use. So skip the shortcuts, close the tutorials for a bit, and start making things work the hard way.

That's the way that lasts.

The Invisible You: Privacy in the Digital Age

Thu, 24 Jul 2025 06:00:00 GMT

On May 24, 2025, I spoke at the Microsoft Mumbai Headquarters to a bright group of IIT Madras students as part of TechWave, hosted by Reskilll and supported by Microsoft Azure. My talk, titled "The Invisible You: Privacy, Security, and Ethics in the Data Age," focused on the often‑overlooked traces we leave online - and why they matter.

Why "The Invisible You"?

Every click, like, or location ping builds a digital shadow. Most people don't realize how quickly that "invisible you" can be assembled:

Surveillance platforms track your habits.
Marketers buy and sell your preferences.
Threat actors exploit leaks and weak safeguards.

That's the framework I wanted to expose - it's not just theory. It's your daily life.

Key Themes from the Talk

The Mechanics of Digital Surveillance

I walked through the pipelines: how personal data is harvested - sometimes with consent, often without - then aggregated, analyzed, and monetized by corporations and governments.

Real-World Risks

Illustrated with examples ranging from micro-targeted political ads to identity theft, I stressed that these aren't abstract - they're real threats that impact autonomy and trust.

Encryption & Ethical Tech

I emphasized the role of encryption and open‑source tools as shields. The message: privacy isn't just about hiding - it's about claiming space to think, create, and communicate freely.

Tools to Reclaim Control

I wrapped up with concrete steps:

Use encrypted messaging (e.g. Signal).
Harden your browser with privacy extensions.
Audit your apps and services regularly.
Stay informed - privacy tech is evolving fast.

Reflections on Audience Engagement

The IIT Madras students asked thoughtful questions: "How can we balance convenience with privacy?" "Is total privacy even possible anymore?"

These conversations highlighted that privacy isn't just technical - it's ethical. And it's about choice.

Slides & Further Reading

You can view the full talk deck here: "The Invisible You" presentation. It's packed with links, visuals, and action points.

Final Thoughts

Talking at Microsoft to such an engaged crowd reinforced something I believe: digital privacy isn't a niche concern. It's a fundamental part of how we live, learn, and connect. If we treat the invisible parts of ourselves as important, we're already stepping toward greater freedom - both online and off.

If you were there, thank you - that chat and curious spirit made it genuine. If you're tuning in now: let's stay cautious, informed, and ethical. The invisible you deserves your attention.

Using the Internet Securely

Sun, 16 Mar 2025 13:15:00 GMT

The internet is a powerful tool, but it comes with risks. Securing your online presence is essential to protect your data, privacy, and communications. One of the most effective tools for encryption and authentication is GNU Privacy Guard (GnuPG), which implements the Pretty Good Privacy (PGP) - Wikipedia standard. This guide covers the basics of GPG/PGP keys and general security practices for safer internet usage.

Understanding GPG/PGP Keys

PGP and GPG use public-key cryptography to encrypt and sign data. Each user has a key pair:

Public Key: Shared with others to encrypt messages for you.
Private Key: Kept secret and used to decrypt messages and sign data.

By using GPG, you can send encrypted emails, verify software integrity, and authenticate communications.

Generating a GPG Key

To create a new GPG key:

Install GPG:
- Linux/macOS: Check installation with gpg --version. If not installed, install it using:
  - macOS: brew install gnupg
  - Linux (Debian-based): sudo apt install gnupg
- Windows: Use Gpg4win
Generate a key:
```
gpg --full-generate-key
```
Follow the prompts to select key type, size, and expiration.

Export your public key:

gpg --export --armor your@email.com > publickey.asc

Share the public key so others can encrypt messages for you. You can upload it to a keyserver like:
- keyserver.ubuntu.com
- keys.openpgp.org

Encrypting and Signing Messages

To encrypt a message:

echo "Confidential message" | gpg --encrypt --armor -r recipient@email.com

To sign a message:

echo "Important document" | gpg --clearsign

To verify a signed message:

gpg --verify message.asc

For more details, refer to the GPG Command Line Guide.

General Internet Security Practices

Use Strong, Unique Passwords

Avoid reusing passwords across different sites.
Use a password manager to store and generate strong passwords.
Recommended Password Manager: GNU Pass (A simple command-line password manager using GPG encryption).
Alternative: KeePassXC (A libre, cross-platform password manager).
You can also visit PasswordManager.com to know more about popular (mostly commercial and non-libre) password managers. NOTE: PasswordManager.com earns a commission on any purchase via their website

Secure Your Email and Communications

Use end-to-end encrypted email services like ProtonMail.
Consider self-hosted email solutions for full privacy, such as SnappyMail (a lightweight, privacy-focused webmail client).
Prefer encrypted messaging apps like Element (Matrix-based).

Keep Software Updated

Regularly update your operating system, browser, and software.
Avoid using outdated plugins and extensions that may introduce vulnerabilities.
Enable automatic updates wherever possible.

Browse the Web Safely

Always use HTTPS.
Avoid clicking on suspicious links or downloading unknown attachments.
Use a privacy-focused browser like:
- LibreWolf (A hardened fork of Firefox with enhanced privacy settings).
- Tor Browser (For anonymous browsing via the Tor network).
- Firefox (Configure it for privacy).
Consider using a libre VPN like Mullvad or Riseup VPN to hide your IP address and encrypt traffic.

Verify Software Integrity

When downloading software, always check its authenticity by verifying its GPG signature:

gpg --verify software.sig software.tar.gz

Most open-source projects provide GPG signatures for their releases, which can be verified against their public keys. Check the project's official website for details.

For example, verifying a Arch Linux ISO download:

Download the public key:

gpg --recv-keys 3E80CA1A8B89F69CBA57D98A76A5EF9054449A5C

Verify the signature:

gpg --verify archlinux-2025.03.01-x86_64.iso.sig archlinux-2025.03.01-x86_64.iso

Conclusion

Online security is an ongoing effort. By using GPG for encryption and authentication, along with adopting strong security habits, you can significantly reduce your risk of data theft and surveillance. Stay informed, keep your software updated, and be cautious when sharing information online.

For further learning:

MAN is Man's Best Friend!

Sun, 02 Mar 2025 13:25:00 GMT

If there's one command that deserves the title of man's best friend in Linux, it's man. The manual (man) pages are your ultimate guide to mastering Linux, unlocking the secrets of the terminal, and supercharging your productivity. Whether you're a beginner or an experienced user, the man command is an indispensable tool in your Linux journey.

1. What is the `man` Command?

The man command (short for "manual") is your go-to resource for understanding Linux commands. Instead of scouring the web for documentation, simply type:

man <command>

For example:

man ls

This brings up the detailed manual for ls, explaining its usage, options, and flags. It's like having an encyclopedia of Linux right at your fingertips.

2. Why `man` is Your Best Friend

Comprehensive Documentation

The man command provides official documentation written by experts. Unlike random online guides, man pages offer precise, up-to-date information about every command available on your system.

Discover Hidden Features

Many Linux commands have powerful yet lesser-known options. By exploring the man pages, you can uncover flags and functionalities that streamline your workflow. For instance:

man grep

reveals advanced pattern-matching techniques that can transform the way you search text.

Boost Terminal Productivity

Instead of switching between a browser and the terminal, stay in the command line and find answers instantly. The more you use man, the more self-sufficient you become, making you a terminal power user.

3. How to Read a Man Page Efficiently

Man pages can seem overwhelming at first, but understanding their structure makes navigation easy:

NAME - A brief description of the command.
SYNOPSIS - Shows how to use the command.
DESCRIPTION - Detailed explanation of what the command does.
OPTIONS - Lists available flags and their effects.
EXAMPLES - (If available) Demonstrates practical usage.
SEE ALSO - Related commands that might be useful.

Navigate a man page using:

j/k - Scroll through the document.
/search-term - Find a keyword.
q - Quit the man page.

4. Advanced `man` Usage

Find Commands by Keyword

Not sure which command to use? Try:

man -k <keyword>

For example:

man -k process

This will list all commands related to "process."

Read Sections of a Command

Some commands have multiple meanings (e.g., printf as a shell command vs. a C function). The manual is divided into sections:

1 - User commands
2 - System calls
3 - Library functions
5 - File formats
8 - System administration commands

To access a specific section, run:

man 3 printf

5. Man Pages: Your Gateway to Linux Mastery

Learning Linux is all about self-sufficiency, and man empowers you to explore, experiment, and understand commands without external dependencies. By mastering man pages, you'll:

Reduce reliance on online searches.
Discover new features and optimizations.
Increase efficiency by staying within the terminal.

Challenge Yourself:

For the next week, try using man before Googling any Linux command. You'll be surprised at how much you learn!

May your terminal adventures be ever productive, and may man always guide your way! 🐧✨

Publishing My First AUR Package: CPIG

Tue, 31 Dec 2024 14:50:00 GMT

Today, I'm excited to share that I've published my first package to the Arch User Repository (AUR)! 🎉 The package is CPIG - Color Palette Inference Generator, a simple C-based tool that generates color palettes from images using the K-means clustering algorithm. It's been a rewarding experience, and I'd love to walk you through the process of creating and publishing a package to the AUR.

What is CPIG?

CPIG is a small, lightweight tool that allows you to extract dominant colors from an image and generate a color palette. It's designed for designers, developers, or anyone who needs a color palette from an image, whether it's for a website, a project, or inspiration.

The tool uses the K-means clustering algorithm to analyze the image and find the most prominent colors, which are then outputted in hexadecimal format. You can easily adjust the number of colors to extract and even save the palette to a text file.

Why Publish to the AUR?

As an Arch Linux user, I've always admired the AUR (Arch User Repository) for its flexibility and community-driven nature. The AUR allows developers to share their open-source projects with the Arch community, and I saw it as the perfect platform for CPIG.

Publishing a package to the AUR not only allows other users to easily install and use your software but also gives back to the open-source community. As this was my first time packaging software for the AUR, I decided to take the plunge and learn about the process, packaging standards, and best practices. Here's how I did it!

The Process of Publishing CPIG to the AUR

Step 1: Packaging the Project

The first step in publishing to the AUR was packaging my project. This involves creating a PKGBUILD file, which is a script that defines how the package is built, installed, and maintained on Arch Linux.

For CPIG, the PKGBUILD script included the project's dependencies, such as the STB Image library for loading images, and instructions for building the program using GCC (GNU Compiler Collection). Once the PKGBUILD was ready, I tested it locally to ensure everything was working as expected.

Step 2: Testing the Package

Before submitting the package, I made sure it was working as intended by testing the build process. I used makepkg to create a local package and verified that the generated binary was functional. I also checked the installation process, ensuring that CPIG installed cleanly and could be run from the terminal.

Step 3: Creating the AUR Submission

Once I was happy with the package, I created an AUR account and submitted the package. The submission process involved uploading the PKGBUILD file, the source code, and any additional files needed to build the package.

After filling out all the details, I submitted the package for review. A few hours later, my package was approved and listed on the AUR! 🎉

Step 4: Maintaining the Package

After the package was live, I started keeping an eye on it. This includes ensuring compatibility with future versions of Arch Linux, fixing any reported issues, and adding features or updates as needed. It's also important to keep the documentation up-to-date so users can easily install and use the package.

Why CPIG is Useful

I created CPIG because I found that many tools for generating color palettes from images were either too complex or didn't give me enough control. CPIG is designed to be simple, lightweight, and customizable, making it perfect for anyone who needs to generate a color palette without all the extra bloat.

Here's what makes CPIG stand out:

K-means clustering for color extraction
Customizable number of colors
Hexadecimal color output
Lightweight and simple design

Installing CPIG from the AUR

Installing CPIG on your Arch Linux system is simple. Once the package is available on the AUR, you can install it using an AUR helper like yay or paru. Here's the command:

yay -S cpig-git

Or, if you prefer to build it manually:

git clone https://aur.archlinux.org/cpig-git.git /tmp/cpig
cd /tmp/cpig
makepkg -si

Once installed, you can use CPIG directly from the terminal:

cpig input.jpg

What's Next for CPIG?

While CPIG is fully functional, I have some exciting plans for future updates:

Optimize the color extraction algorithm for better speed and accuracy.
Support more image formats (e.g., TIFF, GIF).
Enhance the output options (e.g., JSON, CSV, or image previews of the palette).
Improve error handling and user interface for smoother user experience.

I'm looking forward to continuing the development of CPIG and adding more features over time.

Conclusion

Publishing my first package to the AUR was a fulfilling and educational experience. It taught me a lot about packaging, the AUR submission process, and how to maintain open-source projects. If you're an Arch Linux user, I hope you find CPIG useful for your projects. And if you're new to packaging, I encourage you to give it a try-there's no better way to learn than by diving in!

If you'd like to contribute to the project, check out the CPIG repository on GitHub. Whether it's improving the code, adding new features, or simply reporting issues, contributions are always welcome. Open-source projects thrive on community involvement, and I look forward to collaborating with others to make CPIG even better.

Check out CPIG on the AUR and GitHub. Let me know if you have any feedback or suggestions. Here's to more open-source contributions! 🚀

I created PACMAN - not what you think

Sat, 07 Dec 2024 13:10:00 GMT

When it comes to managing your contacts, privacy is often an afterthought. That's why I created PACMAN: Private Alternative for Contact Management And Networking. PACMAN is an open-source, web-based application that gives you full control over your contact data. With features like contact creation, editing, and export to VCF format, PACMAN is designed for individuals and organizations who value simplicity and privacy above all else.

Why Choose PACMAN?

PACMAN is built with a privacy-first philosophy, meaning your contact data stays with you. Unlike other solutions that store your information in the cloud, PACMAN ensures you're always in control.

Here's why PACMAN stands out:

Free and Open Source: Yours to tweak and modify as you see fit.
Web-Based: Access PACMAN securely from any browser on your network.
VCF Export: Export your contacts to the universally compatible .vcf format.
Basic Authentication: Protect access to your contact data with built-in Basic Auth.
Lightweight and Simple: Focused on essential features without the bloat.

Features

Add, Edit, and Delete Contacts: A clean interface makes managing contacts intuitive and efficient.
Search Contacts: Quickly find any contact by name, phone, or email.
Export to VCF: Share or back up your contacts with ease.
Secure Access: Browser-based Basic Authentication ensures only you can view your contacts.

Setting Up PACMAN

Ready to start managing your contacts securely? Follow these steps to self-host PACMAN on your server or local machine.

Prerequisites

Go (Golang) installed on your system.

Installation

Clone the Repository:

git clone https://github.com/itsjustneo-xo/pacman
cd pacman

Build and Run the Application:
```
go run main.go
```
By default, PACMAN will run on http://localhost:8080.

Customizing PACMAN

PACMAN is designed to be configurable with minimal effort. Here's what you can modify in main.go:

const (
    port     = 8080                       // Port to run the app on
    username = "your_username"            // Basic Auth username
    password = "your_password"            // Basic Auth password
    dbFile   = "database/contacts.db"     // Path to SQLite database file
    vcfFile  = "contacts.vcf"             // Default VCF export file
)

Once configured, simply restart the application for changes to take effect.

Using PACMAN

Add Contacts: Fill out a simple form to add new contacts to your database.
Edit or Delete Contacts: Modify details or remove outdated entries in just a few clicks.
Export to VCF: Export your contact list to a .vcf file for easy sharing or backup.
Search Contacts: Use the built-in search functionality to find specific contacts instantly.

What's Next for PACMAN?

PACMAN is continually evolving, with exciting features on the way:

Bulk Import from VCF: Easily migrate existing contacts into PACMAN.
Group Management: Organize contacts into groups for better organization.
Enhanced Authentication: Explore additional security measures beyond Basic Auth.

Conclusion

If you're looking for a simple, secure, and self-hosted solution for managing your contacts, PACMAN is the perfect fit. Whether for personal use or small businesses, PACMAN lets you take control of your data while keeping things lightweight and user-friendly.

Ready to take the leap? Check out the PACMAN repository on GitHub and get started today!

Embracing the Suckless Philosophy: A Minimalist Approach to Computing and Life

Thu, 05 Dec 2024 14:40:00 GMT

After experimenting with Hyprland, a modern and feature-rich Wayland compositor, I recently made the conscious decision to switch back to the Xorg ecosystem with DWM-the minimalist window manager developed under the principles of the suckless philosophy. This choice wasn't just about my desktop environment but rather a deeper reflection of values I want to carry not only in my computing habits but also in my everyday life.

What is the Suckless Philosophy?

The suckless philosophy revolves around simplicity, clarity, and efficiency in software design. The suckless team believes that software should be simple and minimal, avoiding unnecessary complexity that can bog down both machines and developers. Their software-like DWM (Dynamic Window Manager), ST (Simple Terminal), and Slock-adheres to the principle of "keep it simple, stupid" (KISS). This resonates strongly with the Unix philosophy, which advocates for:

Writing programs that do one thing and do it well.
Building small, modular programs that work seamlessly together.
Prioritizing simplicity and elegance over bloat and feature creep.

Suckless projects embody these ideas in their minimalist codebases. DWM, for example, is intentionally under 2000 lines of code, empowering users to audit, customize, and extend the software without wading through layers of abstraction.

Suckless Meets Unix: A Natural Alignment

The Unix philosophy and suckless philosophy share a common disdain for unnecessary complexity. Where Unix emphasizes modularity and composability (think grep | awk | sed pipelines), suckless tools focus on reducing the barrier between the user and the code itself. With DWM, patching the source code directly is the norm, and this DIY approach mirrors the Unix idea of tailoring tools to the task at hand.

This synergy resonates with me. It fosters an environment where I am not just a user but an active participant in shaping my tools to my needs. It also challenges me to be deliberate in what I adopt and to question the value of the tools I use.

My DWM Dots

One of the aspects I love about using DWM is the freedom to make it my own. Over time, I've customized my setup to match my specific workflow and preferences. If you're interested in seeing my configurations or trying them out, check out my DWM dots repository here: codeber.org/itsjustneo_xo/dwm-dots.

In the repo, I've included:

My patches for DWM to add features while maintaining minimalism.
A carefully curated configuration file for an efficient and clean workflow.
Tips and notes for getting started or adapting the setup to your needs.

Feel free to fork or contribute if you share the same love for lightweight, suckless software!

Considering DWL and Wayland

Wayland represents the future of Linux display servers, offering smoother performance and modern features compared to Xorg. I briefly considered making the leap to Wayland full-time with DWL, the suckless-inspired Wayland compositor. DWL offers the same core principles as DWM but for the Wayland ecosystem. However, Wayland's landscape still lacks a broader array of software adhering to the suckless ethos.

For now, I've chosen to wait. I'm watching for more "suckless-esque" projects to emerge that embrace the simplicity, efficiency, and directness I value. While Hyprland was a feature-rich option, its configurability didn't align with my preference for minimalism and auditability.

Extending the Philosophy to Everyday Life

This journey with suckless isn't just about software; it's a reflection of my broader values. In a world obsessed with doing more and owning more, the suckless philosophy has inspired me to do less, but better. Here's how I've started extending these principles to everyday life:

Minimalism: Just as DWM minimizes code and features, I'm decluttering my physical and digital spaces. Whether it's reducing possessions to essentials or cleaning up my digital files, I'm learning to live with less.
Customization: Much like patching DWM to suit my workflow, I'm tailoring my routines and habits to fit my priorities, rather than adopting one-size-fits-all solutions.
Intentionality: The deliberate simplicity of suckless tools reminds me to choose purposefully-whether it's the commitments I take on or the technologies I adopt.

Closing Thoughts

Switching back to Xorg and DWM wasn't just a technical decision-it was a personal choice grounded in values I want to uphold. The suckless philosophy serves as a reminder that less can indeed be more. As Wayland continues to mature and tools like DWL gain traction, I'm excited about the possibility of extending these ideals into the next generation of Linux computing.

For now, I'll continue to build my computing environment with tools that emphasize simplicity and transparency, while striving to bring those same qualities into my life. Because in the end, suckless isn't just about software-it's about a way of thinking and living.

Explore my DWM dots: codeber.org/itsjustneo_xo/dwm-dots

Building MUNDRA: Revolutionizing MUN Delegate Management with Tech

Fri, 22 Nov 2024 12:15:00 GMT

When it comes to managing Model United Nations (MUN) events, the challenges are endless-keeping track of hundreds of delegates, streamlining communication, and planning large-scale events with precision. As the Joint General Secretary - Tech of the MUN Society MPSTME, I decided to tackle these challenges head-on.

That's how MUNDRA - the MUNSoc Delegate Resource Application - was born. Named after the bustling Mundra Port in Gujarat, this backend application is designed to be the central hub for all delegate-related activities. More than just a database, MUNDRA is a scalable, secure, and modular solution that will power everything from our apps to email workflows and websites.

For developers and enthusiasts, MUNDRA's API is fully documented and accessible here, showcasing its well-structured design and functionality.

The Idea Behind MUNDRA

MUNs are as much about organization as they are about debate. Without a centralized system to manage delegate data, events can quickly devolve into chaos. MUNDRA was built to simplify this process by:

Centralizing all delegate and event data into a single database.
Automating repetitive tasks like account management and email verification.
Supporting scalable growth for larger MUN events in the future.
Offering seamless integration with websites, apps, and other tools.

As someone who loves creating meaningful tech solutions, this wasn't just another project for me. It was about building a product that could evolve with our society's needs.

Diving Into the Tech

MUNDRA is built on FastAPI, a modern Python framework known for its speed and simplicity. Here's what makes MUNDRA stand out:

Key Features

Comprehensive User Management
- Delegate accounts with creation, deletion, and updates.
- Email verification ensures only genuine users have access.
- Hassle-free password recovery and change workflows.
Centralized Database
A unified storage system for delegate and event data, enabling easy retrieval and scalability for future growth.
Built-In Security
- Passwords are hashed using modern cryptographic standards.
- JWT-based authentication ensures secure access.
- Additional measures like rate limiting protect against abuse.
Integration Ready
MUNDRA is designed to plug into various tools-our app, event websites, and even automated email scripts.

Why FastAPI?

Choosing the right framework was critical to the success of MUNDRA. FastAPI emerged as the clear winner for its modern features:

Performance: It's built for high-speed asynchronous processing.
Ease of Use: Automatic API documentation and intuitive type hints made development quick and error-free.
Scalability: FastAPI handles high-concurrency environments effortlessly.

You can explore the live API documentation here, powered by FastAPI's built-in OpenAPI support.

Building MUNDRA: Challenges and Lessons Learned

No journey is without its hurdles. Building MUNDRA taught me some valuable lessons:

Challenge: Scalability

MUN events grow larger every year. To ensure MUNDRA could keep up, I carefully designed the database schema and optimized API endpoints for handling large datasets.

Challenge: Security

Account workflows like password recovery are potential attack vectors. I implemented secure password hashing, email token validation, and rate limiting to safeguard user data.

Challenge: Modularity

MUNDRA had to be versatile enough to power apps, websites, and email scripts. I focused on designing clean, self-contained APIs that would work seamlessly across different front-end systems.

The Impact of MUNDRA

The first version of MUNDRA, v1.0.0, is already proving to be a game-changer for our society. With centralized data and automated workflows, we've saved countless hours of manual effort.

This backend isn't just a tool; it's a foundation for future innovation. Whether it's real-time delegate tracking, analytics dashboards, or AI-driven insights, MUNDRA is built to evolve.

Beyond Code: What MUNDRA Means to Me

This project represents more than technical growth-it's a testament to my ability to take an idea from concept to execution. As the Joint General Secretary - Tech, I didn't just build a backend; I created a scalable product tailored to real-world needs.

MUNDRA reflects my passion for leveraging technology to solve problems at scale, and it's something I'm incredibly proud of.

What's Next?

MUNDRA is just getting started. Here's a glimpse into the roadmap:

Real-Time Communication Tools: Instant updates for delegates.
Analytics Dashboards: Insights into delegate participation and event performance.
AI-Powered Tools: Recommendations for committee assignments and event planning.

Explore MUNDRA

Interested in the technical details or want to contribute?

Check out the source code on GitHub.
View the live API documentation at mundra.nnisarg.in/redoc.

Let's build the future of MUN management together.

Dealing With Burnout

Tue, 30 Jul 2024 13:20:00 GMT

Burnout is a prevalent issue among student developers who juggle coursework, coding projects, and part-time jobs or internships. Addressing burnout early is crucial for maintaining your mental health, academic performance, and passion for coding. Here's how you can tackle burnout effectively, including integrating traditional methods like pen and paper, alongside tech-centric strategies.

Recognize the Signs of Burnout

Understanding the signs of burnout is the first step in addressing it. Common symptoms include:

Chronic fatigue and difficulty sleeping
Lack of motivation and decreased performance
Cynicism or negativity towards your studies or projects
Physical symptoms like headaches or stomach issues
Emotional exhaustion and feeling overwhelmed

If these symptoms sound familiar, it's important to take them seriously and address the root causes.

Set Realistic Goals

Unrealistic goals can contribute significantly to burnout. Break down large tasks into smaller, manageable parts, and set achievable deadlines. Track your progress and adjust your goals as needed.

Utilize Pen and Paper for Productivity

Sometimes, stepping away from screens can help reduce burnout and improve focus:

Task Lists: Use a classic notebook or planner to create daily or weekly task lists. Writing things down by hand can enhance focus and help prioritize tasks without the distractions of digital notifications.
Journaling: Maintain a productivity journal to track your progress, jot down ideas, or reflect on your workday. This can be a calming ritual and a way to reduce mental clutter. I personally have a pocket dairy that I keep on me at all times. I use it to jot down 'tech ideas'.
Scheduling: Write down your schedule and use it to set your priorities. Place the written schedule on your desk and look at it from time to time and ensure you stick to it.

Reduce Screen Time and Fatigue

Reducing screen time can alleviate digital fatigue and contribute to overall well-being:

Scheduled Breaks: Use the Pomodoro Technique to balance screen time. Study for 25 minutes and then take a 5-minute break away from screens to stretch or relax.
Screen-Free Time: Designate specific times for screen-free activities, such as reading a book, taking a walk, or engaging in a hobby that doesn't involve screens.
Health Checks: Keep a close eye on your sleep, mood, energy levels, and stress levels. This can help you manage burnout and improve your well-being. I have created a script to remind me to drink water every hour - know more about it here.

Seek Support through Online Communities

Don't hesitate to seek support from your peers and the wider developer community:

Developer Forums: Engage with Stack Overflow for technical questions and Reddit's r/learnprogramming for advice and support from fellow student developers.
Coding Communities: Join tech communities on platforms like GitHub or Discord where you can collaborate, seek advice, and share experiences with others in similar situations.

Know When to Step Away

Sometimes, the best way to manage burnout is to step away from your work. This could mean taking a short break, a mental health day, or reassessing your workload if necessary. A short hiatus can provide the perspective and recharge needed to return to your tasks with renewed energy.

Burnout is a serious issue that requires proactive management. By recognizing the signs, setting realistic goals, incorporating pen and paper methods, reducing screen time, using tech tools to create boundaries, taking tech-supported breaks, seeking support from online communities, and knowing when to step away, you can effectively deal with burnout and maintain your well-being as a student developer.

Unlocking the Magic Behind Seamless Streaming: How HLS Transforms Video Delivery

Sun, 23 Jun 2024 13:40:00 GMT

Have you ever wondered how platforms like YouTube don't load entire videos at once, yet still provide a smooth, uninterrupted viewing experience? Or how you can effortlessly switch between different video quality options to suit your internet speed? The secret lies in the technology called HLS (HTTP Live Streaming). In this blog, we'll explore the wonders of HLS Streams, their various applications, and introduce a powerful API that can convert your videos into HLS Streams effortlessly.

The Mystery of Modern Video Streaming

When you watch a video on YouTube, you might notice that it doesn't buffer the entire video in one go. Instead, it streams seamlessly, even as you skip ahead or switch to a different resolution. This magical experience is made possible by HLS, a protocol that chops video files into small segments and delivers them efficiently based on your internet connection and device capabilities.

What are HLS Streams?

HLS, or HTTP Live Streaming, is a protocol developed by Apple for streaming media over the internet. It divides video content into small chunks and delivers them over HTTP, enabling adaptive bitrate streaming. This means the video quality can automatically adjust based on the viewer's bandwidth and device performance, ensuring a smooth viewing experience with minimal buffering.

Key features of HLS include:

Adaptive Bitrate Streaming: Dynamically adjusts the video quality to match the viewer's internet speed.
Scalability: Uses standard HTTP servers, making it scalable and easy to deploy.
Cross-Platform Compatibility: Supported on a wide range of devices, including iOS, Android, macOS, Windows, and more.

Where are HLS Streams Used?

HLS has become the backbone of modern video streaming, used in various applications, such as:

Live Streaming: Ideal for broadcasting live events like sports, concerts, and news, offering low latency and high audience capacity.
Video On Demand (VoD): Popular streaming services like Netflix and Hulu use HLS to deliver their extensive libraries of movies and TV shows.
Education: Online learning platforms utilize HLS to provide smooth and accessible video lectures and tutorials.
Corporate Communications: Companies leverage HLS for live webinars, training sessions, and important announcements.

Introducing EzHLS: Your Video to HLS Conversion API

To simplify the process of converting videos to HLS Streams, we've developed an API called EzHLS that handles all the complexities for you. Our API is designed to seamlessly integrate HLS streaming capabilities into your applications, ensuring high performance and ease of use.

Features of EzHLS:

Simple Integration: User-friendly endpoints for quick and hassle-free integration.
High Performance: Efficient conversion process ensuring minimal latency and high-quality output.
Scalability: Capable of handling large volumes of video content, making it perfect for both small and large-scale applications.
Customization: Flexible options to tailor the streaming experience to your specific needs.
Self-Hosting: Option to self-host the API for greater control and customization.

You can find the repository for self-hosting on GitHub: EzHLS Repository.

By leveraging EzHLS, you can transform your video delivery system, providing your users with the high-quality, seamless streaming experience they expect.

Conclusion

HLS Streams are the cornerstone of modern video streaming, enabling adaptive, high-quality content delivery across various platforms and devices. With EzHLS, you can effortlessly integrate this powerful technology into your applications, ensuring your audience enjoys smooth, uninterrupted viewing every time. Unlock the magic of HLS today and elevate your video streaming capabilities to the next level.

The Paradox of Popularity: When the Underdog Becomes the Underwhelming

Fri, 03 May 2024 13:05:00 GMT

Have you ever stopped liking a song just because it became popular? There's a curious phenomenon in the vast landscape of trends and preferences-one that often goes unnoticed until it's too late. We tend to root for the underdog, championing their cause until they rise to prominence. But what happens when these once-hidden gems gain the spotlight? Do they shine brighter, or do they lose their luster? Let's delve into this paradox using Linux and music as our guiding examples.

The Rise and Regression of Linux

Linux, the open-source operating system born out of a collaborative spirit, embodies the essence of the underrated turned revered. Initially obscure to the mainstream user, Linux garnered a loyal following among tech enthusiasts and developers. Its customizable nature, robust security, and cost-effectiveness drew praise from those in the know. But as its popularity surged, did Linux maintain its innovative edge?

One might argue that Linux, in its quest for broader appeal, diluted its core principles. User-friendly interfaces were prioritized over technical prowess, leading to a divergence from its original ethos. With popularity came corporate interests, altering the landscape from a community-driven endeavor to a market-driven one. The once nimble and adaptable Linux ecosystem began to lag behind in certain areas, facing compatibility issues and feature bloat.

The Melody of Mainstream Music

Turning our attention to the realm of music, a similar narrative unfolds. Consider any of your favorite (underrated) artist that captures hearts with its raw talent and unique sound. As their music gains traction, they attract a larger audience and record label attention. Soon, their once-distinctive style starts to conform to industry norms, losing the very essence that made them special. The allure of mass appeal can transform the soulful into the formulaic, leaving fans nostalgic for the early days of discovery.

Reflections and Realizations

In pondering these examples, one can't help but wonder-does popularity inherently lead to a decline in quality? Is there a tipping point where the pursuit of a broader audience sacrifices the essence of what made something exceptional?

Perhaps the answer lies in the delicate balance between accessibility and authenticity. When the underrated gains popularity, it's crucial to preserve the elements that made it remarkable in the first place. Innovation, community engagement, and a steadfast commitment to core values can shield against the pitfalls of mainstream success.

As consumers and advocates, we play a pivotal role in shaping the trajectory of these phenomena. Our choices, support, and feedback serve as guiding forces in ensuring that the underdogs we championed don't lose their shine amidst the spotlight.

So, the next time you stumble upon a hidden gem-be it in technology, art, or culture-ask yourself: how can we elevate its visibility without compromising its essence? The answer may just lie in celebrating the underrated while safeguarding its magic from the perils of popularity.

Unveiling My Digital Arsenal: What I Use

Wed, 28 Feb 2024 13:50:00 GMT

Welcome, to my digital sanctuary! In this ever-evolving landscape of technology, I've carved out my own niche, a haven where innovation meets productivity, and creativity thrives. Join me on this journey as I peel back the layers of my digital realm, revealing the tools, hardware, and development stack that power my every endeavor.

Inside My Workstation:

Step into my workspace, where innovation takes flight. Here, Arch Linux reigns supreme, providing the solid foundation upon which my digital adventures unfold. Paired with the sleek efficiency of i3wm, navigating through tasks feels effortless, like a well-choreographed dance. When it's time to delve into the intricate world of code, neovim emerges as my stalwart companion, guiding my fingers through lines of logic and creativity. And for traversing the vast expanses of the internet, I rely on the steadfast companionship of Firefox and Google Chrome (only used while developing websites), guiding me through the digital wilderness with ease.

If you're curious about the intricate workings of my workspace, feel free to take a peek at my i3 configuration.

Hardware Highlights:

Beneath the surface of this digital tapestry lies a robust infrastructure, meticulously crafted to support my every endeavor. At its core, a AMD Ryzen 5 3500X CPU, coupled with a Nvidia GeForce GTX 1660 Super GPU, form the beating heart of this technological marvel, ensuring smooth sailing whether I'm engaged in intense work or immersive gaming experiences. 16GB of Corsair Vengance LPX 3200MHz DDR4 RAM keeps the gears turning seamlessly, while my ViewSonic VA2406-MH monitor delivers crisp visuals that breathe life into every pixel.

For input, I've forged a custom Corne Split Keyboard, a testament to personalization and ergonomic excellence. When it's time to envelop myself in the world of sound, I alternate between the CrossBeats Roar 2.0 for travel and the Audio-Technica ATH M40X headphones for immersive experiences. And in the realm of communication, the Fifine Ampligame A6V mic and Redragon Hitman GW800 webcam stand as guardians, ensuring seamless connectivity in a world that thrives on collaboration.

On the go, my Samsung Galaxy A23 keeps me tethered to the digital pulse of the world. Also, my old 81DE Lenovo ideapad 330-15IKB laptop is used as a server via Cloudflare Tunnels and it steps up to the plate, ready to provide my coded creations to the world!

Development Stack:

In the realm of development, I've curated a stack that seamlessly blends efficiency with creativity, empowering me to bring my ideas to life with unparalleled finesse. With Astro as my frontend framework, crafting dynamic web experiences becomes a joyous endeavor, with limitless possibilities at my fingertips. TailwindCSS, complemented by a touch of custom CSS, lends a touch of elegance and flair to my creations, ensuring they captivate and inspire. And when it's time to delve into the depths of backend development, Flask and FastAPI emerge as the unsung heroes, providing the flexibility and performance necessary to breathe life into my projects.

That's but a glimpse into the intricate tapestry of technology that fuels my productivity and creativity. Feel free to explore further or drop me a line if you're curious about anything specific!

Organizing My First Hackathon: A Journey of Discovery and Growth

Wed, 20 Dec 2023 13:35:00 GMT

Embarking on the journey of organizing my first hackathon - Debate-a-thon was an exhilarating experience that taught me invaluable lessons. From initial planning to execution and beyond, the process was a profound learning curve. In this blog, I'll share the key takeaways and insights gained during this transformative adventure.

Collaboration is Key

One of the fundamental lessons learned was the importance of collaboration. Working alongside a talented team brought diverse perspectives and skills to the table. The collective effort not only streamlined the organizational process but also fostered an environment of creativity and innovation.

Meticulous Planning Pays Off

The meticulous planning required for a successful hackathon cannot be overstated. From defining the event structure to coordinating logistics, every detail played a crucial role. Creating a comprehensive timeline, anticipating challenges, and having contingency plans in place ensured a smooth and well-executed event.

Embrace the Unexpected

No matter how well you plan, unexpected challenges will arise. Embracing these challenges with a flexible mindset and quick problem-solving abilities is essential. Adapting to unforeseen circumstances not only kept the event on track but also provided opportunities for creative solutions.

Judges Elevate the Experience

The inclusion of esteemed judges added a layer of expertise and credibility to Debate-a-thon. Their insights not only enriched the competition but also provided valuable feedback for participants. Securing knowledgeable and engaged judges is a crucial aspect of hosting a hackathon.

Personal Growth and Future Prospects

Beyond the organizational aspects, this experience has been personally enriching. The skills acquired extend far beyond the realm of event planning -

Leadership: Orchestrating Debate-a-thon honed my leadership skills, from guiding a team to steering the event towards success, paving the way for future endeavors.
Communication: Clear and effective communication was paramount in coordinating a complex event, emphasizing the pivotal role of communication skills in diverse collaborations.
Problem-Solving: Tackling unexpected challenges during the hackathon showcased the importance of adaptability and quick problem-solving, skills applicable to a spectrum of real-world scenarios.

The holistic development of these skills extends beyond event planning, shaping a foundation for future innovative ventures. The hackathon has opened doors to new opportunities and collaborations, setting the stage for future innovative ventures.

Conclusion

Organizing my first hackathon was a transformative experience that left an indelible mark on my professional and personal growth. The lessons learned, from collaboration and planning to adaptability and community engagement, are invaluable assets for future endeavors. As I look ahead, I'm eager to apply these insights to create more meaningful and impactful events in the dynamic world of technology and debate. The journey has just begun, and I'm excited to see where it leads.

Become a CSS God: Simple tips to get better at CSS

Mon, 18 Sep 2023 13:45:00 GMT

Are you ready to ascend to the ranks of CSS godhood? CSS (Cascading Style Sheets) is a fundamental skill for web development and design, and mastering it can make you feel like a deity in the web development world. Whether you're a beginner or looking to level up your CSS skills, here are some divine tips to guide your journey.

1. Know CSS Inside and Out

Before you can become a CSS god, you must first become one with CSS. Even if you use a utility-first CSS framework like TailwindCSS, it's crucial to understand the core principles of CSS. Know the properties, values, selectors, and the magic behind the cascade. This knowledge forms the foundation of your godly CSS powers.

2. Box Model Mastery

The box model is the divine blueprint of web layout. Understand it completely, from the innermost content to the outermost margin. Delve into properties like width, height, padding, margin, and border. Knowing how these properties affect the box model will empower you to craft pixel-perfect designs.

3. Flexbox and Grid Layout

flexbox and grid are divine gifts to web developers. Master these CSS layout models, and you'll effortlessly bend web layouts to your will. They can simplify complex layouts and help you achieve responsive designs that shine on any screen.

4. Mobile-First Approach

Begin your styling journey with the humble mobile device. By starting small, you bite the toad in the morning, ensuring your designs are inherently responsive. This approach not only pleases the gods of user experience but also makes your life easier when scaling up to larger screens.

5. Modular CSS

Harness the power of modular CSS to keep your codebase organized and maintainable. Break your styles into smaller, reusable components, and follow naming conventions like BEM (Block, Element, Modifier). Modular CSS allows you to summon styles with ease, like invoking spells in a magical incantation.

6. Practice and Projects

The path to godhood is paved with practice. Create small projects, experiment with CSS, and explore its depths. Replicate existing websites to learn different CSS techniques and unravel the mysteries of beautiful web design. With each project, you ascend closer to CSS divinity.

But wait, there's more! To truly reach the zenith of CSS mastery, consider these additional factors:

- Performance

Optimize your CSS for performance. Minimize your stylesheets, use efficient selectors, and optimize images. The faster your web pages load, the more your users will worship your creations.

- Accessibility

Embrace the divine duty of making the web accessible to all. Use semantic HTML and provide alternative text for images. Test your designs with accessibility tools, ensuring that everyone can access your web creations, regardless of their abilities.

In your quest to become a CSS god, remember that the journey is just as important as the destination. Embrace the learning process, stay curious, and always seek ways to improve your skills. With dedication and practice, you'll soon find yourself crafting web experiences worthy of the gods themselves. May your CSS reign supreme! 🌟✨

"How do I learn to code?" Here's how:

Sun, 10 Sep 2023 14:05:00 GMT

So, you've decided to dive into the world of coding, but you're not sure where to begin? That's perfectly normal. Starting your coding journey can be intimidating, especially if you have little to no prior experience. But fear not! In this blog post, I'm going to guide you through the process of how I would start to learn to code, based on my own experiences and insights.

Choosing Your Path

The first step in your coding journey is to decide which programming path interests you the most. There are numerous fields in coding, each with its unique charm. Here are some popular ones to consider:

Web Development: If you want to create interactive websites and web applications, web development might be your calling. You'll learn languages like HTML, CSS, JavaScript, and various frameworks like React or Angular.
App Development: If building mobile apps is your dream, then app development is the way to go. You'll need to choose between iOS (Swift) or Android (Java/Kotlin) development.
Internet of Things (IoT): If you're fascinated by smart devices and the idea of making everyday objects smarter, IoT is a great choice. You'll work with hardware and software to create connected devices.
Game Development: Gamers might find game development intriguing. You can create your own video games using engines like Unity or Unreal Engine and learn languages like C# or C++.
Data Science: If you love data and want to extract insights from it, data science could be your path. You'll work with languages like Python and tools like TensorFlow or PyTorch.

My Personal Journey

I started my coding journey with web development because the idea of creating websites that anyone could see was incredibly motivating. Your interests might be different, and that's perfectly fine! The key is to find something that excites you.

To get started, I relied heavily on YouTube videos. YouTube is an excellent resource for beginners, as it provides step-by-step tutorials and demonstrations. I would recommend watching a couple of videos related to your chosen path to get a sense of how things work.

Learn by Doing

While watching videos is a great way to grasp the basics, learning to code is a hands-on experience. To truly understand and retain what you've learned, I suggest following along with a few projects within your chosen domain. You can find countless project tutorials online that take you through building real-world applications.

The importance of hands-on practice cannot be stressed enough. Don't just copy and paste code from tutorials. Take the time to understand each line and experiment with it. Coding is about problem-solving, and you'll learn best when you encounter and overcome real challenges.

Utilize Free Resources

One of the most incredible aspects of learning to code is the wealth of free resources available online. You don't need to spend a fortune on courses or textbooks (unless you want to, of course). Here are some fantastic resources that can help you get started:

W3Schools: W3Schools offers an extensive collection of tutorials and examples for web development technologies like HTML, CSS, JavaScript, and more. It's an excellent resource for beginners to learn the fundamentals.
GeeksforGeeks: GeeksforGeeks provides a wide range of tutorials and articles on programming, data structures, algorithms, and more. It's a valuable resource for improving your coding skills and understanding complex concepts.
YouTube Videos: YouTube is a treasure trove of coding tutorials. Many passionate educators create video content covering various programming topics. Find channels that align with your interests and learning style.

Additionally, platforms like GitHub provide a space to access open-source projects and collaborate with others. GitHub is not only a code repository but also a vibrant community where you can learn from experienced developers, contribute to projects, and showcase your own work. If you're curious, feel free to check out my GitHub profile to see some of my own coding projects and contributions. It's a great way to get inspired and connect with fellow developers in the community.

These resources are not only free but also highly accessible and can be incredibly beneficial as you embark on your coding journey.

Document Your Journey

As you progress in your coding journey, it's crucial to document your work and projects. Even if your projects seem simple, they are a testament to your growth as a programmer. Documenting your work helps you keep track of your progress and can serve as a portfolio for future job opportunities.

Furthermore, sharing your work with the world, whether through blog posts, social media, or open-source contributions, is a great way to motivate yourself and inspire others. It also opens doors to receive feedback and learn from the coding community.

In conclusion, learning to code is an exciting journey filled with opportunities for creativity and problem-solving. Start by choosing a path that resonates with you, leverage free resources, practice what you learn by working on projects, and document your progress. Remember that the key to success is persistence and a genuine passion for coding. So, take that first step and embark on your coding adventure! Happy coding!

Nnisarg's Blog

How to Improve Your Programming Skills (By Building Everything Yourself)

Why Building from Scratch Works

1. Build a Minimal HTTP Server

2. Write a Simple CLI Tool

3. Implement a Basic Encryption System (for Learning Only)

4. Build a Tiny Database

5. Design a Mini Framework

DO Re-Invent the Wheel - That's How You Master Programming

How to Start

The Invisible You: Privacy in the Digital Age

Why "The Invisible You"?

Key Themes from the Talk

The Mechanics of Digital Surveillance

Real-World Risks

Encryption & Ethical Tech

Tools to Reclaim Control

Reflections on Audience Engagement

Slides & Further Reading

Final Thoughts

Using the Internet Securely

Understanding GPG/PGP Keys

Generating a GPG Key

Encrypting and Signing Messages

General Internet Security Practices

Use Strong, Unique Passwords

Secure Your Email and Communications

Keep Software Updated

Browse the Web Safely

Verify Software Integrity

Conclusion

MAN is Man's Best Friend!

1. What is the man Command?

2. Why man is Your Best Friend

Comprehensive Documentation

Discover Hidden Features

Boost Terminal Productivity

3. How to Read a Man Page Efficiently

4. Advanced man Usage

Find Commands by Keyword

Read Sections of a Command

5. Man Pages: Your Gateway to Linux Mastery

Challenge Yourself:

Publishing My First AUR Package: CPIG

What is CPIG?

Why Publish to the AUR?

The Process of Publishing CPIG to the AUR

Step 1: Packaging the Project

Step 2: Testing the Package

Step 3: Creating the AUR Submission

Step 4: Maintaining the Package

Why CPIG is Useful

Installing CPIG from the AUR

What's Next for CPIG?

Conclusion

I created PACMAN - not what you think

Why Choose PACMAN?

Features

Setting Up PACMAN

Prerequisites

Installation

Customizing PACMAN

Using PACMAN

What's Next for PACMAN?

Conclusion

Embracing the Suckless Philosophy: A Minimalist Approach to Computing and Life

What is the Suckless Philosophy?

Suckless Meets Unix: A Natural Alignment

My DWM Dots

Considering DWL and Wayland

Extending the Philosophy to Everyday Life

Closing Thoughts

Building MUNDRA: Revolutionizing MUN Delegate Management with Tech

The Idea Behind MUNDRA

Diving Into the Tech

Key Features

Why FastAPI?

Building MUNDRA: Challenges and Lessons Learned

Challenge: Scalability

Challenge: Security

1. What is the `man` Command?

2. Why `man` is Your Best Friend

4. Advanced `man` Usage