Forem: Samay Kumar

AI Can Write Code, But Can It Ship an App? My Experiment

Samay Kumar — Wed, 04 Mar 2026 21:44:39 +0000

Why I Decided to Try This

There’s a lot of hype right now around AI tools that can supposedly build entire applications. You often see demos where an AI writes code, opens pull requests, and produces a working app with very little human involvement.

I wanted to see what that actually looks like in practice.

So I gave myself a small experiment: build a simple mobile app with as much help from AI as possible and see where things work and where they break.

For this experiment I used OpenAI Codex and asked it to generate the base of the application.

The goal wasn’t to build something complicated. I wanted something small enough to test the limits of AI-assisted development.

The site is live at

https://gurbani247.samay15jan.com

but what mattered to me was everything happening behind it.

The Idea Behind the App

The app itself is intentionally simple.

It streams Gurbani continuously from a URL and shows a visualizer while the audio plays. That’s essentially the whole concept.

The feature set was kept minimal:

Continuous Gurbani streaming
A music visualizer
A clean mobile interface
Background playback support
Basic device indicators (network, battery, time)
Hidden status bar for a cleaner UI

The stack generated by the AI used:

React Native
Expo
NativeWind

Which is a fairly standard setup for lightweight mobile apps.

What AI Did Well

At the start, the experience was honestly impressive.

Within minutes, the AI generated the base project structure, the UI layout, and the core logic for streaming audio. It also created the visualizer components and applied styling using NativeWind.

A basic working version of the app appeared very quickly.

This is where AI tools are genuinely strong. They are extremely good at generating the first version of a project. Tasks like setting up folders, writing component boilerplate, and wiring up UI layouts can be done very quickly.

At that stage it almost feels like the AI can build everything.

But that impression doesn’t last very long once the project moves beyond scaffolding.

Dependency Problems

The first major issue appeared when trying to run the project.

The configuration generated for NativeWind didn’t work properly with the current ecosystem setup. Expo and NativeWind had compatibility issues in the latest versions, and the generated configuration simply failed.

Fixing the issue required manually going through documentation and eventually downgrading to a more stable version of the dependency.

The AI kept generating configurations that looked correct but still didn’t work in a real environment.

This is something AI currently struggles with. It can generate code that looks valid, but it doesn’t fully understand the constantly changing state of real-world dependencies.

Background Audio

Another requirement was background playback. The audio stream needed to continue playing even if the app was minimized or sent to the background.

The implementation suggested by the AI looked correct at first glance, but it didn’t actually work.

No matter how the prompts were adjusted, the audio kept stopping when the app moved to the background. Eventually I had to manually debug the issue and implement the correct behavior based on documentation and experimentation.

This became another example of AI generating something that appears reasonable but fails in real execution.

Android Notification Media Controls

Android usually exposes playback controls directly in the notification panel so users can pause or resume audio without opening the app.

The AI attempted to implement the player controller for the notification area. The generated code looked reasonable, but on actual devices the controls didn’t function properly.

The issue only became clear when testing on real hardware.

Fixing it required additional debugging and experimentation before the media controls started behaving correctly.

CI/CD and GitHub Workflow Failures

I also asked the AI to generate a GitHub workflow to automate building the project.

It produced a YAML configuration, but the workflow repeatedly failed when executed.

Some blocks in the generated configuration caused the pipeline to break, and the build never completed successfully.

After several attempts, I ended up writing the workflow myself and fixing it through a few rounds of trial and error until the pipeline worked properly.

The Small Problems That Break Everything

One of the biggest limitations I noticed during the experiment is that AI struggles with small problems that break an entire workflow.

In real development, the hardest problems are rarely large architectural issues. They’re usually small details:

a dependency mismatch
a missing permission
a configuration error
a CI pipeline step failing

These small issues can stop a project from working entirely.

Humans usually identify these quickly through debugging and experimentation. AI often keeps generating slightly different versions of the same broken solution without identifying the underlying cause.

What the Real Workflow Looked Like

After working through the project, the development process looked very different from the idea that AI simply builds the entire application.

The workflow usually looked like this:

AI generates the initial implementation
The project fails to run
I debug dependency or configuration problems
AI helps generate smaller pieces of code
I integrate everything and fix the next issue

Then the cycle repeats.

In practice, AI behaves more like a very fast assistant rather than an autonomous developer.

The Final Result

After resolving the issues and finishing the missing pieces, the final application includes:

continuous Gurbani streaming
a working audio visualizer
background playback
Android notification media controls
device information indicators
a cleaner interface with the status bar hidden

I also created a web version of the project. Once the core logic was clear, building the web implementation was significantly easier, and AI was more effective in helping with that part.

Future Possibilities for iOS Builds

One possible direction for the project is generating iOS builds in the future.

It should be possible to create unsigned IPA files using my project:

https://github.com/samay15jan/altux

The goal of that project is to simplify generating unsigned IPA builds that can later be installed using alternative signing methods.

Getting something like that working requires a lot of experimentation and trial-and-error. It involves testing different build processes, reading documentation, and slowly figuring out how the tooling behaves.

This kind of iterative research process is something AI currently struggles with.

What I Learned From This Experiment

After finishing the project, one thing became very clear.

AI is extremely good at generating the first 70–80% of a project.

It can scaffold applications, generate UI components, and produce large amounts of code very quickly.

But the final part of development — the part where everything must actually work together — still requires real engineering.

AI currently struggles with:

dependency conflicts
ecosystem changes
CI/CD reliability
environment-specific bugs
real device testing
small workflow-breaking problems

These areas still rely heavily on human debugging and reasoning.

Final Thoughts

Despite the limitations, the experience was still impressive.

Without AI assistance, building the first version of this project would have taken significantly longer. With AI, the initial version appeared very quickly.

However, turning that initial code into a stable, working application still required manual debugging and decision-making.

The most accurate way to describe AI coding tools right now is that they behave like a very fast junior developer.

They can produce a lot of code quickly, but they still require supervision, corrections, and guidance from someone who understands the system.

From Code to Production: Automating Deployment on Oracle Cloud

Samay Kumar — Mon, 02 Feb 2026 06:26:03 +0000

Over the last few days, I worked on setting up the deployment and automation for my personal portfolio website. The frontend itself was intentionally not the focus. I reused an open-source template so I could spend my time understanding how real deployments work once code leaves local development. Having rebuilt my portfolio multiple times before, I wanted to shift my attention toward infrastructure and automation.

The site is live at https://samay15jan.com, but what mattered to me was everything happening behind it.

My goal was to build a system where pushing code to GitHub would automatically update the live server without manual intervention and without downtime. This required understanding how CI/CD, containerization, traffic routing, and server security work together in practice.

At a high level, the workflow begins with a push to GitHub. This triggers a GitHub Actions pipeline that builds a container image and publishes it to GitHub Container Registry. The pipeline then connects to my Oracle Cloud virtual machine over SSH and executes a deployment script directly on the server.

Instead of stopping the running version and starting a new one, I implemented a blue–green deployment strategy. Two environments exist on the server, but only one receives traffic at any time. The new version is deployed to the inactive environment, health checks are performed, and traffic is switched only after verification. If anything fails, the previous version continues running without interruption.

The blue–green deployment script can be found here:

https://gist.github.com/samay15jan/296498459d1607226b8a59d4ae7b3385

NGINX sits in front of the containers and handles all incoming requests. It also manages HTTPS using Let’s Encrypt and routes traffic to the currently active environment. From the user’s perspective, deployments are invisible and the site remains online throughout the process.

The server runs on Oracle Cloud Infrastructure using Ubuntu Linux. I chose OCI because it provides a free-tier instance that is ideal for students experimenting with real infrastructure. Firewall rules are managed using UFW, allowing only required ports. This part was especially valuable to me, as self-hosting exposes details that managed platforms often abstract away...and those details are where most meaningful learning happens.

Later, I purchased a custom domain through Cloudflare and connected it to NGINX. Cloudflare is used for DNS management, while HTTPS is handled through Let’s Encrypt on the server.

This project taught me that deployment is not just a final step. I gained a practical understanding of blue–green deployment and why running NGINX directly on the host instead of inside application containers and helps reduce downtime. Since containers are disposable by nature, keeping the reverse proxy external allows deployments to occur without affecting traffic.

This project was not about building a portfolio page. It was about understanding how software actually reaches users and how that process can be automated safely.

Going forward, I plan to automate my blogging workflow and gradually move all personal projects under a single self-hosted system. My long-term goal is to run services on demand using containerized workloads (Just like Render have), with a strong focus on performance, reliability, and maintainability.

I also plan to explore Kubernetes to manage container health and long-running services more effectively. Working with Oracle Cloud Infrastructure opened up many new ideas for me, and it has significantly shaped how I think about building and operating systems in the future.

The source code is available at:

https://github.com/samay15jan/portfolio

The live deployment is running at:

https://samay15jan.com

Breaking Into Apple’s Walled Garden (Almost)

Samay Kumar — Mon, 18 Aug 2025 18:29:15 +0000

Introduction

All I wanted was simple solution to a bigger problem:

Develop and run my own app on my own iPhone without paying Apple a dime.

If you’ve ever tried developing for iOS, you know how locked down the ecosystem is. Unlike Android, where you can just download and install an APK, iOS has always been about control. Apple decides what goes in, and unless you pay $100/year, own a Mac, to test and follow their endless rules—you’re stuck.

That’s fine if you’re a big company. But for students, indie devs, or hobbyists on Windows/Linux, it feels impossible.

And yet, I found a way.

Not a perfect way. Not a sustainable way. But it just works.

The Early Days of Sideloading

My journey started with something very non-serious and personal: removing ads from YouTube on iOS.

On Android, we have coughs…ReVanced and other mods. On iOS? Things weren’t so easy. I stumbled upon sideloading and thought it meant jailbreaking at first. Turns out—it didn’t.

I grabbed some cracked .ipa files (basically iOS’s version of .apk) but had no idea how to install them. That’s when I entered the chaotic world of sideloading tools: Sidestore (which didn’t work), Sideloadly (with no Linux support), Sideloader (almost worked) and finally AltStore + AltServer-Linux which brought some magic with more problems along the way.

AltStore was a revelation but only when you understand its working. But then came Apple’s infamous 3-app limit. I tried hacking around it: running multiple Docker containers, different Apple IDs, even modding AltStore into “AltStoreX”, just to bypass the limit.

Still after days of .plist editing which itself was pain, especially when binaries get messed up, I got two different AltStore instances working independently on one device… only to realize the 3-app limit is tied to the device itself , not the Apple ID. Brutal.

Eventually, I discovered TrollStore, which exploited a vulnerability (like macdirtycow) to bypass refresh limits entirely. No 7-day expiry. No re-signing. It was glorious.

(Caveat: TrollStore only works on specific iOS versions/devices.)

The Real Problem

Sideloading mods was fun, but the real problem hit me when I started working on my own app:

Sparklines Mobile, a music streaming app built with React Native + Expo (unfinished and might never be anyways).

On Android, Expo’s EAS build system worked flawlessly. I could build an .apk and install it in minutes.

On iOS? Different story.

Simulator builds only, not real .ipas
Need a paid Apple Developer Account
Need macOS + Xcode for building, and a specific iOS device to test it
and distribution is impossible too

As someone on Linux, that was a dead end. But then I had a thought:

What if I could just get an unsigned .ipa and sideload it manually?

Apple wants that to happen only on macOS. Challenge accepted.

The Breakthrough

While digging around, I noticed projects like uYouPlus and EeveeSpotify were building .ipa files using GitHub Actions on macOS runners.

That’s when it clicked:

Why not do the same for Expo apps?

I spent hours fighting with YAML configs, debugging failed builds, and experimenting with different workflows. Eventually, I managed to get GitHub’s macOS runners worked the way I wanted and generate an unsigned .ipa and sideloaded with AltStore/TrollStore.

Guess what ? It worked.

I had my own React Native app running on my iPhone—no Mac, no paid Apple account, nothing.

Sure, crashes were ugly (probably because I hadn’t set up error boundaries properly within my application codebase), but native modules worked fine. It felt surreal.

The Tool That Could Have Been

At this point, I considered turning the whole process into a tool. Maybe:

A CLI to auto-generate the GitHub Actions workflow
Or a web app frontend where you could link your GitHub account and upload code, and it spits out an .ipa. Something like Vercel for mobile apps.

PS: There are things like webmuxd which could be a game changer.

Basically, a free alternative to Expo’s paid EAS service—but for people who just want to test and learn without Apple’s gatekeeping, legally and ethically, and for personal use only.

I had some ideas and minimal executional logic… but never turned into something real. And maybe i didn’t even need to anymore. I was already moving away from iOS.

Still, I pushed what I had to GitHub: Altux

You could refer to GitHub Action template and README file in the repository for some nitty gritty, behind the scenes working.

If anyone wants to build on top of it, go ahead.

Conclusion

This whole thing started because I just wanted to test an iOS app without paying Apple. And in the process, I learned a lot about sideloading, CI, and Apple’s walls.

I’m not maintaining this project, and I’m not sticking with iOS either. But maybe this little experiment will help students, indie devs, or tinkerers who just want to learn without paying $100/year for the privilege.

Apple may have a walled garden, but sometimes a crack in the wall is all you need to learn, build, and experiment. Altux was mine. Waiting for yours…

How I Built a TUI Without Leaving the Terminal

Samay Kumar — Mon, 14 Apr 2025 00:41:27 +0000

What does TUI even mean?

Terminals are an overly complexified yet quick way to interact with the system and any task without leaving the terminal... ever. TUI stands for Terminal User Interface. Basically, it's a way to use some software features directly from the terminal with a user-intrusive interface, and use the keyboard to control everything.

I know you might not understand it at first, because terminals are complex in their own way. So, it’s a step forward.

PS: In this article, don’t expect much of a learning experience, it's more about me showcasing a project I built for the terminal. And it’s definitely not gonna help you in your career ever. haha. So proceed wisely.

Why TUI matters

We live in a world where everything is graphical, flashy, and requires 12GB of RAM to open a note-taking app (~~Definitely not targeting Notion~~). But sometimes, being raw is power. Terminals give you that rawness.

It’s not just about nostalgia or being geeky for fun. TUI tools are:

Blazing fast (like seriously instant)
Keyboard-driven, so your hands never leave the keys and forget the mouse even exists
Often more scriptable and composable
Lightweight and can run on toasters (or potatoes, if u prefer them)

For devs, sysadmins, hobbyists, and even minimalists, TUI is not just a UI – it's a philosophy.

And if you can make your own (even if it’s not fully polished)? Damn right it's still worth flexing.

What did I do?

A long time ago, somewhere in February of 2024, I got an idea to build myself a music streaming platform, 'caz at that time I was good with frontend web development. But I wanted to expand more, and what's the best way to learn than hands-on experience? That’s how I started learning backend. Fast forward 6–7 months, my web application was ready. I’ll explain the entire workflow in some other blog someday. For now, u can refer to GitHub here.

So, from here I got an idea—why not use the custom backend (which I built on top of an open-source project here—I can’t remember if it was v2 or v3. idk) and build a terminal user interface to control music directly from the terminal? (Because other open-source projects were related to Spotify TUI and required a paid account with Spotify open in the background). But I needed something based on my use case, which I could run in the background while I was lost in coding sessions and didn’t eat up 60% of my RAM. I needed something like a command to run, and I could play any song I want directly from the terminal itself. After all, it’s going to be the coolest way to stream your music from the terminal!

NOTE: Just to be honest — it doesn’t "stream" like you think. My custom backend (built on top of JioSaavn) grabs the full song URL. Then I just pass that URL to mpv, a media player. Simple and effective, yet works like a charm.

For quite some time, this project was just sitting idle in my TO-DO list while I did my research on finding the perfect way I could do that. And that’s when I found Ink. It's a way I can use React for interactive command-line apps. Yeah, it's old but it’s a well-maintained and documented open-source project. I found it to be a perfect fit for my use case, ‘caz I did know JS/TS well and had hands-on experience in React itself. So, I believed it was going to be fun to build. Also, I couldn't find anyone who took this approach to build a highly intrusive TUI with React and Ink specifically, so either I’m making history or I’m one step closer to becoming that mad guy. Win-Win situation haha.

So, I went all in. Can’t truly recall how long it took me to build—somewhere around a month.

Oh shit... been talking all this time and didn’t tell u what I named it: Sparklines-TUI. hehe

Tech Stack

Languages & Tools:

NodeJS + TypeScript
Ink and Ink-UI
mpv (for music playback)
Custom backend (on top of JioSaavn)
Socket & fs handling in Node for communication with mpv
Works in Termux (Android) (unstable)
Vim/Google IDX (now Firebase Studio)

Some features are not yet implemented, but the basic functionality has been achieved, though there might be unknown bugs. You can report here, and chances are I might never fix them. hehe, so try doing some work yourself, and contributions are welcome.

Building the UI

Definitely, React + Ink streamlined the approach to build the tool, because I was able to use previous web development knowledge and not much of a learning curve either. It was definitely something worth it. I know people will say it's not good, design/system architecture sucks, should’ve used Rust or ncurses or something similar, and so on. Definitely agree with some things, but the reason I built it was to solve a problem I couldn’t find a solution for anywhere. So I created it for myself, and it serves the purpose and works as expected. Also, Rust or ncurses introduces a steep learning curve.

My work environment

I used Vim mostly while I was building this. I cloned the Ink repo to read docs side by side. Definitely worth it. Vim itself is a skill, though it’s not that good for actual coding, and messing around with nvim felt like a burden. So I switched gears to a cloud IDE (Google IDX) for development, and it did increase my coding speed a lot, especially with Nix package management.

Challenges in the journey

The biggest challenge I faced was getting some sort of way to play music. So I picked the easiest route—I directly implemented it with mpv and I channeled logs of mpv (which had timestamps, which I needed) to a log file under the .sparklines folder, and managed it with a socket (a two-way communication endpoint to handle the custom commands). With the power of NodeJS, I made it work out and somehow it turned out a lot better than expected. Also, configuration files can be accessed at .sparklines/config.

For sure, Ink was something ahead of its time. It has everything one needs to build something like this. At least for fun. I faced challenges when I was working with the UI itself, though it took me some time to perfectionate it and make it modular and work with custom shortcuts. Packaging was a very simple and quick task.

BTW, u can get it directly using npm i sparklines-tui -g.

Some Features

Control music directly from the terminal
Login/Register functionality
API key-based interaction with Sparklines Backend
Continuous playback (still buggy) and clean playback bar
Custom shortcuts & help menu (Alt+h)
Search songs, albums, and artists
Music language selector
Recommendations & infinite play (work in progress) [TODO]
Loop, shuffle, queue, and lyrics support (coming soon) [TODO]
NPM packaged and works on Termux (to some extent)

For installation, refer to docs.

Help Menu

Some useful commands (can be accessed through Alt + h):

Tab                 → Navigate between sections  
Spacebar            → Toggle between play and pause  
Enter               → Select the selected item  
Ctrl + m            → Mute/unmute the audio  
Ctrl + x            → Hide other section  
Ctrl + z            → Toggle search  
Ctrl + a/s/d/f      → Focus on menu/playlists/simulation/other section  
Ctrl + k/l/;        → Toggle between search/lyrics/queue section  
↑ and ↓             → Navigate up and down between items  
] or [              → Increase/decrease volume by 5  
Ctrl + ➡ / Ctrl + ⬅ → Seek forward/backward by 5 seconds  
Ctrl + ➡ / Ctrl + ⬅ → Increase/decrease speed by 0.2x  
Alt + h             → Display/close this help menu  
Esc                 → Quit the app

Final Thoughts

I don’t expect anyone to care (but u should care). Honestly, this was more for me. To learn, to experiment, to see if I could push the limits of terminal UI in JS. And it did that. And that’s what matters the most. If you're building something and it excites you, then even if no one else claps, you've still won.
Do let your thoughts flow in comments.

Until next time. stay in terminal. peace.

Originally published on https://blog.samay15jan.xyz

Part 1: Getting Started With Linux

Samay Kumar — Wed, 26 Mar 2025 21:40:22 +0000

Introduction to Linux

What is Linux? Million Dollar Question

Linux is a kernel for computer systems that is used worldwide. Yeah, even the social media you use on your phone could be backed up by a Linux server. Some people call it an operating system. However, Linux itself is only the kernel. When combined with other components like software utilities and libraries, it forms a complete OS, often called a "Linux distribution"—you will get to know about it later in this blog.

Why is Linux important?

Firstly, here are some solid stats from TrueList:

96.3% of the top one million web servers are running Linux. (ZDNet)
Yep, the very same Linux is powering a whopping 85% of smartphones out there. (Linuxblog)
The world’s top 500 fastest supercomputers all run on Linux. (Blackdown)
47% of professional developers (like me) use Linux-based operating systems. (Statista)
Today... maybe not when you are reading this, there are over 600 active Linux distros. (Tecmint)

Most importantly, Linux is also one of the biggest open-source projects, which means all its code is publicly accessible. Anyone—maybe even you after reading this blog—can modify and distribute its code, and it’s developed collaboratively with our very own Linux community.

Which means it gives freedom and a sense of independence directly into the hands of the user to do whatever they want, without any higher body governing like what we usually get in other OSes, while maintaining the latest updates which don't take hours to install—that too at zero cost.

Did you know?\
Windows gets shattered,\
Apples get rotten,\
but penguins, they don’t drown... wait... do they?\
Fires up browser..."can penguins dieee?"\
Waits... waits intensively...\
Google: "Please verify you are not a robot."\
Clicks... clicks... submit\
Google: "Yes, penguins do die like every other living organism, you dumbass. But they do live longer than Windows and Apples."

The Birth of Linux

The backstory of Linux is straightforward. At the heart of it all is Linus Torvalds, an incredible programmer, who laid the foundation bricks for what we now know as Linux. Over the years, a global community of talented developers has built on that foundation, continually enhancing and evolving the system.

That's all you gotta know. You can anytime fire up Wikipedia and learn about the cheeky little details, but I would recommend—theory is not something you should focus much on, especially for technical stuff. For your knowledge, surely go for it.

But for now, that's out of the goals for this blog.

Understanding the Computer System Architecture

Layers of a Computer

Let's understand the working of a computer. According to my research, there are basically three main layers of a computer:

Layer 1: This is the hardware layer, which consists of the physical components of the computer, such as the CPU, memory, storage devices, or that RTX 4090 Ti graphics card which you asked your mother to buy, stating it is the bare minimum for your studies.
Layer 2: This is the kernel, the most crucial layer in the system. It acts as an intermediary between the hardware and the software, managing resources like memory, processing power, and devices. The kernel ensures that software can interact with hardware safely and efficiently.
Layer 3: This is the user interface layer, where users interact with the system. It includes the graphical user interface (GUI) and applications. This layer allows users to perform tasks such as browsing the web, creating those boring presentations, and running programs.

Think of the kernel as the manager of all system resources. It ensures that software can talk to the hardware and access resources, but it also ensures that the system runs efficiently and securely by controlling access and managing tasks.

NOTE: If you want to dive deeper into the relationship between the computer and hardware, consider checking out this.

The Role of the Kernel in Linux

Here are some of the key roles the kernel plays as an interface between hardware and software:

Process Management - Handles the creation, execution, and termination of processes.
Memory Management - Allocates and deallocates RAM for processes in a sandboxed manner.
Device Management - Controls hardware devices such as keyboards, mice, or any plug-and-play device like USBs via device drivers.
File System Management - Handles file read/write operations, including access control and permissions for files and directories.
Networking - From IP addresses to firewalls, even the communication between processes over networks is handled by the kernel.

Setting up your playground

Before moving forward, I personally have this ideology that any knowledge learned by hands-on experience will help you grasp concepts more quickly and efficiently. You can skip this part, but it would be good if you give it a shot.

Installing Linux (Virtual Machine, Bare Metal, WSL, Cloud)

To start using Linux, I personally would recommend going with Pop!_OS.
You got a few options here: either you can run it on a VM or install it on Bare Metal.
Don't worry, I got you covered—you can use any one of the following methods:

Virtual Machine (Recommended):

It's like installing an OS inside your running system but virtually, which means you don't have to worry if you mess up something. Your main system will work just fine.
Here are the steps:

Install either VirtualBox or VMWare on your Windows/Mac machine (for this, your device must support virtualization, which should work in most cases unless you have a very old/potato PC, or you might have to enable it in BIOS. Follow some tutorials for that—it's not a big thing).
Download the Linux Pop!_OS ISO from here. You could try Ubuntu too.
Simply create a new VM, allocate RAM and storage, load the downloaded ISO, and run it.
Follow the on-screen instructions to install Linux or use the live environment.

Note: There are plenty of guides on the internet—just follow any one.

Bare Metal:

This step involves installing Linux directly on your system. It will delete your Windows forever, and you cannot recover it. There are ways like dual booting (installing two OSes on one device). But for now, let's focus on a clean installation of Linux on your system:

Download the Linux Pop!_OS ISO from here. You could try Ubuntu too.
Download and install Balena Etcher or Rufus for creating a bootable USB.
Get at least an 8GB empty USB stick and plug it into your system.
Run Balena Etcher or Rufus, import the downloaded ISO, and start the process.
It will take 5-10 minutes to create a bootable USB.
Now, based on your device brand, find its boot keys—just Google it.
Reboot your system and say goodbye to Windows.
Press the boot keys when booting, select your USB stick, and click enter.
Now, after booting, you will be presented with a live environment. Whatever changes you make here will be gone with a reboot.
Now, simply follow the on-screen instructions and make a clean install on your storage device.

Note: Unfortunately, this method is not possible on Apple devices. Though there are ways, they are complicated.

IMPORTANT: Installation on Bare Metal is not recommended for beginners because there is a higher chance you could lose all your data, and I don't want you to curse me for that.

Windows Subsystem for Linux

It's a method to run Linux directly on your Windows system using the subsystem for Linux. It's a very straightforward method for any Windows user:

Check if your device supports virtualization.
Open PowerShell as Administrator.
Run wsl --install.
That's it; it will install Ubuntu by default.

INFO: Earlier, it was a long process to do, like configuring in the control panel to enable the WSL service, then proceeding with manually installing it from the Microsoft Store, and it wasn't that feature-rich.

Thank God Microsoft streamlined this feature to make it quick and efficient.

Cloud

This process allows us to spin up a virtual machine directly on the cloud. Though they do cost some money, it's a good option if you are already familiar with services like AWS/Azure/GCP. You can also use third-party services like Linode.

If you just need to get familiar with the command-line interface, Google IDX is a good option, as it provides a terminal window where you can practice commands and also learn the NIX package manager. On the other hand, you can use Google Cloud Shell too, which also uses an APT-like package manager.

There are infinite possibilities; it just depends on what you are comfortable with. The basic commands on Linux are the same everywhere. Every distro has a layer on top to make some repetitive processes easy. That's it. Nothing else.

Linux Distributions: What Are They and Why So Many?

Now, you might be thinking, why did I recommend you use Pop! OS or Ubuntu? What are they, and so on? Good question... Next question?... Joking.

Look, as I said, Linux is a kernel, which uses a lot of other utilities that make it an OS for performing different tasks. These utilities can be anything (desktop GUI, icons, fonts, tools, drivers, etc.).

Linux has multiple distributions (also known as flavors). As stated earlier, there are about 600+ distros (short for distributions), each with its own purpose, use cases, and communities built to maintain them and provide forums for support.

Some Major Linux Distros:-

Ubuntu: A Debian-based Linux distro, famous for its user-friendly nature and interface, which is somewhat similar to Windows. It’s popular for beginners and is also widely used in server environments.
Kali Linux: A specialized Linux distro primarily used by penetration testers, ethical hackers, and security researchers. Kali comes preloaded with a wide range of security and forensic tools.
Linux Mint and Pop! OS: Lightweight distros, also based on Ubuntu and Debian, designed to be easy to use and very similar to the traditional Windows desktop experience.
Arch Linux: A minimalist, DIY distro that follows the KISS (Keep It Simple, Stupid) principle. Arch is favored by advanced users who want full control over their system. It’s not beginner-friendly but offers total customization. (I use Arch, by the way!)
Fedora: A cutting-edge, community-driven distro with a focus on free and open-source software. It is often used by developers and those who want the latest features in an enterprise-friendly package.
And more like Slackware, openSUSE, Alpine, etc.

I know it's confusing, and once you go deeper into the rabbit hole, you will explore more and more overly complicated stuff like Gentoo, Linux From Scratch, and a lot more.

Concept of Distro Hopping and How to Overcome It

It's common for people who start using Linux to get lost in distro hopping (the process where users try out the most popular Linux distros to find a perfect fit for them).

We all have been through that phase, and here are a few tips to avoid it:

There are only 3-4 main distros on which others depend: Debian, Arch, Fedora & openSUSE.
Never judge a distro based on its looks; you can replicate any theme, UI, or specific feature of one distro on another using Package Managers (it's like a place where you download software/tools from, just like the Microsoft Store or App Store. More on that later).
What matters is your use case.
- For developers: Recommend Arch or Fedora due to their rolling releases.
- For general users: Ubuntu or Mint for a user-friendly experience.
- For security professionals: Kali Linux or Parrot Security OS.
That's it. There are thousands of distros out there, but in reality, they are just some visual enhancements. That's it. I like to call them Niche distros.

TIP: Don't Fall into the Distro Hopping Trap

Pick a distro, stick with it, and get better at it.

There’s no need to constantly jump between distros. If you're a beginner, Debian or Ubuntu are great choices. For more experienced users, Arch is ideal for customization & advanced users, and Fedora is the go-to for enterprise use.

HINT:

In future articles, we might explore some ways you can create your very own distro too. Stay Tuned.

Did you know?

There are even some distros like Hannah Montana Linux, Biebian (for Justin Bieber fans), Red Star OS (North Korea's official Linux distro, you can imagine how great that would be), and even Linux XP (mimics Windows XP).

The Command Line: The Heart of Linux

The core concept of Linux is getting familiar with the terminal. Yeah, it's that black screen with the blinking cursor—that's the Command Line Interface (CLI). I know it can be overwhelming for many (maybe everyone starting out... I was too). I actually tried avoiding it as much as possible in the initial days of my Linux switch. But eventually, we have to use it, and that's the hard pill to swallow. However, once you actually understand the power of the terminal, you might never leave it again.

Here are a few solid reasons why it's a must-have skill:

Day-to-day tasks like listing, editing, removing, and copying files in folders get easier.
Understanding package managers (depending on the distro) to install software.
Unlike Windows, downloading software is different. Linux users prefer commands like wget and curl to download something. But don't worry—there are download buttons too, haha.
Managing and configuring WiFi and the internet becomes easy.
Configuring user permissions, checking system resources, creating or running scripts, and a lot more... basically everything you could ever imagine.

Now that we know how powerful terminals are, let's quickly address some of the basic commands every Linux user should know:

ls – List files in a directory
- Example: ls shows all files and folders in the current directory.
pwd – Show the current directory
- Example: pwd will display the full path to your current directory (e.g., /home/user).
cd – Change directory
- Example: cd Documents moves into the "Documents" folder.
- cd .. moves up one directory level.
echo – Display text or values
- Example: echo "Hello, World!" prints the text on the screen.
cp – Copy files or directories
- Example: cp file1.txt file2.txt copies the contents of file1.txt to file2.txt.
mv – Move or rename files or directories
- Example: mv oldname.txt newname.txt renames the file.
rm – Remove files or directories
- Example: rm file1.txt deletes the file file1.txt.
- Use -rf to delete a folder directly.
mkdir – Create a new directory
- Example: mkdir new_folder creates a new directory named "new_folder".
rmdir – Remove an empty directory
- Example: rmdir empty_folder removes an empty directory.
cat – Display file contents
- Example: cat file1.txt shows the content of file1.txt on the screen.
man – View the manual for a command
- Example: man ls shows the manual page for the ls command, helping you understand how to use it.
touch – Create an empty file
- Example: touch newfile.txt creates an empty file named newfile.txt.
clear – Clear the terminal screen
- Example: clear clears all text from the terminal, giving you a clean screen.
history – View your command history
- Example: history shows the list of commands you’ve used in the terminal.
exit – Exit the terminal session
- Example: exit closes your current terminal window.

TIP

Linux terminals can be overwhelming at times, especially when we are just starting out. And for this, we have a helper, i.e., man. Nice naming, isn't it? It's like how we ask questions in real life, "Man, what is this?" Silly jokes aside.

We can use this command like man <TOOL_NAME>, for example, man ls or man lsblk. It gives us complete A-Z usage of the tool directly from the terminal. In Linux, it’s more about reading first than implementing.

Many tools also have their own help menus, which we can access by -h or --help. It gives us a sweet little usage guide using flags.

BTW, anything starting with - or -- in a command like --help is known as a flag. We can use multiple flags in one command to ease our life.

Text Editors

Text editors are basically used to edit files quickly. Vim, Nano, and Emacs are all different types of text editors.
The difficulty levels for these are: Nano > Vim > Emacs.

Suggestion: If you ever accidentally stumble upon vim, don’t worry—you can exit it with esc then :q!. It’s something that will definitely make you mad at first.

Linux File System Structure

Unlike the Windows file system, Linux has a more structured and hierarchical approach. Everything in Linux is a file—whether it's system drivers, memory processes, configuration files, or even hardware-related components. This design makes Linux extremely flexible but also requires a bit of understanding to navigate efficiently.

Users and Groups in Linux

Before we understand where files are stored and how access is managed, we need to know who controls them—this is where users and groups come in.

Users in Linux

In Linux, the most important user is root. Think of it as an admin (or in layman’s terms, we can call it the god of Linux). The root user has unrestricted access to the system, similar to the Administrator account on Windows, but with even more control. So, the root user has enough access to break the entire system or completely wipe everything (which is something very common if you don't pay attention).

However, as we know, with great responsibility comes great risk, meaning using root directly is dangerous. This brings up another question: How do we use the system?

Basically, in Linux, we can have multiple users, not just one or two—potentially infinite. One device can be used by many people, just like in Windows where we can create users. It’s a similar concept. All users have their own directory where only their data is saved, and no other user can access it.

Groups in Linux

Not all users have the same responsibilities or permissions. We can’t trust everyone fully, so instead of manually assigning permissions to each user (which is a hectic task), Linux allows us to group users together.

Users can be assigned to a group, making management easier. Groups work just like teams in a company—each group has specific permissions, making it easier to manage access control.

User Management Commands:-

I know theory is boring, so let's dive into practicals:-

Create a new user:

- `sudo adduser <USERNAME>` *// here `<USERNAME>` should be replaced by the desired username*
- Creates a new user and sets home directory (`/home/<USERNAME>`)
- It will ask you to set a password for the user too

Delete a user:

- `sudo deluser <USERNAME>`
- This removes the user but doesn’t delete the home directory
- `sudo deluser --remove-home <USERNAME>` *// deletes home directory too.*

Change user password:

- `sudo passwd <USERNAME>`
- Prompts you to enter the new password for the user

Switch to another user:

- `su - <USERNAME>`
- To return to your previous user, type: `exit`

Create a new group:

- `sudo addgroup <GROUPNAME>`

Add a user to a group:

- `sudo usermod -aG <GROUPNAME> <USERNAME>`
- The `-aG` option adds the user to the group without removing them from other groups

Remove a user from a group:

- `sudo deluser <USERNAME> <GROUPNAME>`

List groups for a user:

- `groups <USERNAME>`

Check current user:

- `whoami`

View User ID (UID) and Group ID (GID):

- `id <USERNAME>`

You might not know

Specific commands like addgroup, delgroup, adduser, deluser are for Debian-based distros.

But, in Arch Linux, it's groupadd, groupdel, useradd, userdel commands.

The reason it's like this is that, in Debian-based distros, it acts as a wrapper for the same command (visual enhancement only) that Arch Linux uses, as they are true to UNIX fundamentals, which suggests that Arch sticks to roots and keeps things minimal.

Understanding the Linux File System Hierarchy (FHS)

UNIX-based systems are known for their File System Hierarchy Standard (FHS). It's basically the entire file structure of the system. As we know, everything in Linux is a file, so its management is really important.

Common Directories and Their Functions:-

Directory	Purpose
`/` (root)	The top-most directory; everything starts from here.
`/bin`	Essential programs (like `ls`, `cp`, `mv`, `rm`). Used by all users.
`/boot`	Bootloader configurations for booting (like `EFI`, `Grub`, `ReFind`).
`/dev`	Device files (like `/dev/sda` for hard disks, `/dev/null`, `/dev/sdb` for USB devices).
`/etc`	System configuration files (e.g., `/etc/passwd`, `/etc/fstab`).
`/sbin`	System-related binaries (like `fsck`, `iptables`, `shutdown`). Used mainly by root/admin.
`/home`	Home directories for users (`/home/user1`, `/home/user2`).
`/root`	Root user’s home directory (not in `/home`).
`/var`	Variable data (logs, caches, databases) like `/var/log/syslog`.
`/usr`	User-installed software and libraries (`/usr/bin`, `/usr/lib`). `/usr/local/bin` for custom executables.
`/tmp`	Temporary files that are deleted on reboot.
`/proc`	Virtual directory for process and kernel info (`/proc/cpuinfo`).
`/mnt`	Temporary mount point for external drives.
`/media`	Auto-mounted external drives (USBs, DVDs).

Navigating the File System Using the Terminal

As we have already discovered commands like ls, cd, pwd, now let's go a little deeper to understand things more:-

Absolute Path: Full path from the root (/) directory.
Example: /home/user/Documents/file.txt
Relative Path: Path relative to the current directory.
Example: If you're in /home/user/, then cd Documents is the same as cd /home/user/Documents.

Some Navigation Tips:-

cd .. → Move up one directory
cd - → Switch to the previous directory
cd ~ or just cd → Move to your home directory
cd ~/home/user/Documents → Move to a specific folder (if you are familiar with paths, which you will be as you practice.)
ls -l → Long format listing (permissions, ownership, size, etc.)
ls -a → Show hidden files (files starting with .)

Common Linux Filesystems

A file system manages how data is stored, retrieved, and structured on a storage device. It includes:

Data Structure → Defines how files, directories, and metadata are stored.
Journal & Recovery → Some file systems support journaling for data protection.
Performance & Efficiency → Affects read/write speeds and storage optimization.
Features → Encryption, snapshots, compression, deduplication, etc.

Filesystem	Features
`ext4`	Default, stable, widely used.
`XFS`	Great for large files, high performance.
`Btrfs`	Supports snapshots, data integrity, and compression.
`ZFS`	Best for data integrity, RAID-like features.
`exFAT`	Works across Windows, Linux, macOS.

NOTE:
For beginners, it's common that you might be on your desktop or VM, so I would recommend going for ext4. It's the most widely used filesystem, very stable, and not hardware-intensive. As you get familiar, you can try the other filesystems as needed. But keep in mind, basic fundamentals stay the same.

Mounting and Unmounting File Systems

Mounting a Device:

sudo mount /dev/sdxx /mnt # sdxx can be sda1, sdb, etc.
ls /mnt

Unmounting:

sudo umount /mnt

Permanent Mounting (fstab): To auto-mount a partition at boot, add to /etc/fstab

UUID=xxxxx /mnt ext4 defaults 0 2

NOTE: You can find UUID using lsblk -f

Hard Links vs. Soft Links and Symlinking

Hard Links
- A hard link is an additional name for the same file, no extra storage used.
- If you delete the original file, the data remains.
- Best for backups, redundancy, efficiency.
- Eg: ln file1 hardlink1.
Soft Links (Symbolic Links)
- A symlink points to another file’s path, not its data.
- If you delete the original file, the symlink breaks.
- Best for shortcuts, cross-partition linking.
- Eg: ln -s file1 symlink1.

Conclusion

That was a lot to process, but there's even more just around the corner.

In the upcoming blogs, we’ll dive deeper into Linux, covering system administration, security, troubleshooting, and more. Who knows? You might build your custom Linux distro by the end of this series. Stay tuned!

Remember— Practical > Theoretical

Originally published on https://blog.samay15jan.xyz

Why I Started Blogging

Samay Kumar — Sat, 07 Dec 2024 18:29:15 +0000

A little about me

Hi, there a random user, welcome to my first ever blog. Thou i am not sure whom i am greeting to cauz i don’t think anyone would ever read it. Haha…laughing at my own jokes, my old act.ShowShareButtons: true

Lemme introduce me to yeah all, especially those Google’s web crawlers. I am Samay Kumar , known to no one by username samay15jan.

Am a Software Developer by profession (i consider myself in my good books), but in reality am a just keen learner who just tries to explore technologies…yeah u can call me a tech enthusiast.

My journey to blogging

If i really be honest, i don’t exactly consider it as a blog. I’m just here to express myself to the world without having any barriers. It’s a place where my voice is the only thing u could hear…voice ? hear ? Seriously, whats wrong with me.

I gained my inspiration for blogging from a random user on internet named Peter Boone.

So on a fine day, after a long break in my coding journey, i wanted to try something fun. Eventually, i questioned myself “How exactly does Spotify scan codes actually works ?” more about in this blog.

And from there i stumbled on one of his article, suddenly an idea ignited. An idea to start to start something similar just so that i can have my very own corner on internet.

So, here i am using hugo with papermodx theme and writing my very own blog about “Why i started blogging”.

What can u expect ?

Let’s quickly address the key points of what can u expect with these blogs, cauz it helps in…_ coughs _…SEO Ranking. _ Ehh ? _ Sorry, User Experience:-

Gain ultimate knowledge from your top notch blogger.
Learn about tech tutorials, cool tricks and alot more
A place where ~~i can waste my time~~ u can get a better understanding of complex stuff in simplest and fun manner.
Learn how not to get inspired by your top notch blogger, so u get an idea what not to do.
Exclusive insights about latest and older tech from your very own top notch blogger.

Note: Enough bragging, simply these blogs shouldn’t be a thing u should entirely trust on, do your research, let that brain of yours do some work.

Conclusion

After all of those heart touching words from your neighborhood blogger, u should conclude that, u guys are going to get some good knowledge, tutorials, insights of technologies and learn from the mistake i made (which i am not going to share hehe).

But still keep your eyes open for the mind boggling beginning of our new journey, where i am as blank like u are after reading this blog, cauz we both don’t know what is gonna happen next.

See yeah on the other side.

PS: Never trust a 20 years old top notch blogger who just started out.