Forem: Ash Ketchum

Manjaro, Manjaro

Ash Ketchum — Fri, 24 Oct 2025 07:36:57 +0000

I am back with a technical post again. This time, I want to talk about Manjaro, which is a Linux distro based on Arch.

I have been a user of Ubuntu Linux for a few years now. To be precise, it has been at least 3 years and 3 months since I stopped using garbage Windows. Ubuntu is infinitely better than that, but it is meant for beginners. After graduating from that level, it was high time to start using a more advanced Linux distribution.

So here I want to document how I dual-booted Manjaro Linux, and in the process show off some useful Linux commands at the level of the operating system hardware. We will also go over filesystems and partitions, as well as some basics about the bootloader and the boot process. Hopefully, by following the way I have done it, slowly and with documentation, you will see that dual-booting doesn’t have to be as scary as it is made out to be.

First, some history

This was not my first attempt at dual-booting. That was back in my first year of college, when I first heard about Linux as a cool alternative to Windows. Digging around a little, I found that a beginner’s distro called Ubuntu was the perfect way to introduce people to Linux. Having little experience and a lot of enthusiasm, I straight-up dual-booted Ubuntu alongside Windows 10 with little regard to partitions and disk space.

This was all fine as long as I was just learning the various Linux commands, but when I wanted to do more with Ubuntu, like watch videos, install software, or attend my online classes (this was peak COVID time), I found out that the 30 GB of space that I had allocated to Ubuntu was not sufficient. Not at all.

I removed and dual-booted Ubuntu again. And again. And again. In total, I dual-booted at least 6 times. Each time, something or the other went wrong. Sometimes, there was insufficient memory, or the wifi driver would not work, or the computer was overheating, or I nuked the OS with some commands in the terminal (not as foolish as sudo rm -rf /, but something equivalent). Finally, when everything was working, my computer decided to call it quits, and the motherboard went kaput.

So yeah, a lot of things happened. A lot of it was because my laptop, an HP laptop, was optimised for Windows and not Linux, so a lot of the hardware was not utilised properly, leading to issues. But a lot of it was also because I was trying to do things in such a rush that I didn’t stop to sort out issues and document them, instead taking them head-on all at once.

A lot of other development happened after that, but tldr; I bought a new Dell Laptop which came shipped with Ubuntu, and got some experience using the terminal. Along the way, I also became a Vim enthusiast and a user of i3wm. And one day, I woke up and chose violence- I mean dual-boot again: this time, with Ubuntu and Manjaro.

The Helper

An important difference now is that we have a lot of LLMs around to help us. Every LLM is good at different things, and as things go, Claude is quite good when it comes to technical topics. So, I decided to take its help in dual-booting properly this time. No rush, only results.

First, I wanted to make sure that my system had enough space to handle another OS, so I started off with Claude with my first question:

I continued to use Claude during my entire work, and honestly, it has been quite a fun sidekick to me on this journey. If used correctly, AI can be a really great helper.

ISO on USB

I have been using i3wm with Ubuntu for some time, so it was a natural choice to transition to Manjaro i3. It can be downloaded from the official website easily. After this, I bought an 8GB pendrive and made it bootable with the ISO. This can be done using a graphical tool like Startup Disk Creator or Balena Etcher. Or, if you want to go hardcore, there is the dd Linux command that does the same thing, but from the terminal.

Firstly, check using the lsblk command to find where our pendrive is mounted:

> lsblk
NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
loop0         7:0    0     4K  1 loop /snap/bare/5
loop1         7:1    0 184.8M  1 loop /snap/chromium/3218
loop2         7:2    0 184.8M  1 loop /snap/chromium/3235
loop3         7:3    0 104.2M  1 loop /snap/core/17212
loop4         7:4    0 104.2M  1 loop /snap/core/17247
loop5         7:5    0  55.5M  1 loop /snap/core18/2934
loop6         7:6    0  55.5M  1 loop /snap/core18/2940
loop7         7:7    0  63.8M  1 loop /snap/core20/2582
loop8         7:8    0  63.8M  1 loop /snap/core20/2599
loop9         7:9    0  73.9M  1 loop /snap/core22/2082
loop10        7:10   0  73.9M  1 loop /snap/core22/2111
loop11        7:11   0  66.8M  1 loop /snap/core24/1055
loop12        7:12   0  66.8M  1 loop /snap/core24/1151
loop13        7:13   0  68.4M  1 loop /snap/cups/1085
loop14        7:14   0  67.2M  1 loop /snap/cups/1100
loop15        7:15   0   604M  1 loop /snap/gnome-46-2404/121
loop16        7:16   0 618.3M  1 loop /snap/gnome-46-2404/125
loop17        7:17   0  62.1M  1 loop /snap/gtk-common-themes/1506
loop18        7:18   0  91.7M  1 loop /snap/gtk-common-themes/1535
loop19        7:19   0 290.8M  1 loop /snap/mesa-2404/887
loop20        7:20   0 290.8M  1 loop /snap/mesa-2404/912
loop21        7:21   0  12.9M  1 loop /snap/snap-store/1113
loop22        7:22   0  12.2M  1 loop /snap/snap-store/1216
loop23        7:23   0  49.3M  1 loop /snap/snapd/24792
loop24        7:24   0  50.8M  1 loop /snap/snapd/25202
loop25        7:25   0   568K  1 loop /snap/snapd-desktop-integration/253
loop26        7:26   0   576K  1 loop /snap/snapd-desktop-integration/315
loop27        7:27   0 321.1M  1 loop /snap/vlc/3721
loop28        7:28   0 321.1M  1 loop /snap/vlc/3777
sda           8:0    1   7.5G  0 disk 
└─sda1        8:1    1   7.5G  0 part 
nvme0n1     259:0    0 238.5G  0 disk 
├─nvme0n1p1 259:1    0   925M  0 part /boot/efi
├─nvme0n1p2 259:2    0     8G  0 part 
└─nvme0n1p3 259:3    0 229.6G  0 part /

The output looks daunting, but in fact, it is just very helpful. Let’s take a slight detour to understand what is going on here.

What the loop?

If you noticed, the output contains a lot of devices of type loop. You might be asking what that is. To understand that, we first need to know more about storage devices and how they are read by operating systems.

There are two separate things going on here. Firstly, there is the physical hard disk or SSD or whatever, made out of atoms and storing data in the form of magnetic platters or electric charges. Then, there is the software in the operating system to read the storage device to actually gain access to the memory inside it. Without the operating system, the hard disk is just a glorified paperweight. As Douglas Hofstadter would put it, the hard disk is the first level of information, the operating system is the key, and the actual bytes inside it are the hidden level of information.

Think of it like a chest full of gold. Just having the chest (hard disk) is not enough. You also need a key (operating system) to open (mount) the chest (hard drive) and gain access to the gold (memory) inside. This explains the actual devices: sda, which is my USB with 7.5 GB usable space in a single partition, and nvme0n1 representing my SSD with 238.5 GB usable space, which is divided into three partitions.

Notice that my pen drive is attached but NOT mounted. This can be seen from the output, as there is nothing under its MOUNTPOINTS column. This is like having the chest but not opening it, so we can’t actually access any memory inside it. Similarly, my SSD has two of its partitions mounted at the root and boot level, respectively, and an 8 GB unmounted partition.

Apart from these actual physical devices, Linux simplifies accessing several virtual devices, such as snap. Linux allows users to create special block devices by which they can map regular files to a virtual block device. Basically, they can allow you to treat a regular application as a new file system without creating a new partition. This is very helpful for sandboxing and segregating data, and the reason why Canonical, Ubuntu’s parent company, makes snap packages accessible as virtual devices using loops.

For our purposes, we don’t need to worry about loops at all. The only thing that matters is the name of the system representing the pen drive, /dev/sda.

Using dd

The dd command needs our pendrive to be attached but unmounted. If not already so, we can do it using:

sudo umount /dev/sda1

Then, we just need to specify our ISO file and the filesystem which we want to overwrite, in this case, our pen drive (Make sure you don’t overwrite your SSD instead!).

sudo dd if=~/Downloads/manjaro-*.iso of=/dev/sda bs=4M status=progress oflag=sync

With this step, we are done with the creation of a bootable pendrive! Now, I had to get around UEFI secure boot to actually boot from it.

UEFI Secure Boot

The modern boot process in Linux systems is controlled by a piece of software called the firmware. The firmware is a piece of software embedded into hardware to control its basic functions, acting as a bridge between the hardware and other software. In other words, the firmware is the link that makes the machine ‘trick’ itself into consciousness, to use GEB verbiage.

A key part of making the firmware work is the bootloader, which is another piece of software that coordinates the handing over of the computer to the operating system once the firmware is done with its boot process (BIOS). The bootloader initialises the hardware and loads the operating system(s) into memory. It then gives the user a choice to select which operating system to run, or if there is just one of them, it goes on and gives control to it.

That brings us to the UEFI Secure Boot. Basically, the bootloader knows only one thing: to execute whatever instructions it gets. No security checks. Someone can load up a malicious OS, and your entire session will be compromised without a hint of it. To counteract this, manufacturers have to adhere to a standard called Unified Extensible Firmware Interface (UEFI), which, among other things, provides secure boot.

It means that only trusted or standard operators are allowed to boot up. To check this, the OS software must be digitally signed by the manufacturer, or else it won’t boot. Since our bootable pendrive is not signed, the computer doesn’t boot it up. I think it has something to do with the fact that this laptop was shipped in with Windows…[1]

To overcome this, we have to set Secure Boot to false. This does mean that anything can now boot up without any checks, but come on, when was the last time you booted something without knowing what it was? This setting can be accessed as part of the BIOS settings, which can be brought up by pressing during the boot process. Once I disabled Secure Boot and booted with my USB, I was welcomed with:

Live Testing

When I dual-booted Ubuntu for the first time on my old laptop, I first did all the partitioning, gave it real estate on my hard drive, and then discovered that something important, mostly hardware like wi-fi or the cooling fan, was not working. Determined not to repeat this mistake, I live-tested my distro with USB booting for about a week before plunging in.

When testing from the USB, any changes you make will be stored in the RAM and will go away as soon as you shut down the laptop or unplug the USB. In a way, this is advantageous, as we can do all sorts of experiments and absolutely wreck the distro and then again come back to it clean and pristine after one reboot. And that’s exactly what I did :)

I tested booting both with open-source and proprietary drivers, and found that open-source works better for me. To know which peripheral hardware your computer is using, we can use the lspci command.

A quick check with Claude cleared it for me that my peripheral hardware was best suited with open-source drivers, and that’s what I found from experience as well.

Apart from this, I did wreck the distro by calling sudo pacman -Syu in the terminal. This is equivalent to typing sudo apt update && sudo apt upgrade for Ubuntu, and basically updates every software installed (but without restarting the computer, make Windows do that!). In USB mode, this quickly overwhelmed my RAM, as the installation size can often go into GBs, and hung my computer till I forced it to shut down. But this won’t happen in an actually installed system.

To remember the important steps that I must do in a fresh install (or reboot), I went the usual programmer’s way and documented it all in a GitHub repository. And I also mounted my Ubuntu partition for read-only access so that I could copy over the important stuff from there into my repo. This can be done by mounting the appropriate partition onto a mount point (a folder basically). So,

> sudo mount /dev/nvme0n1p3 /mnt

will mount Ubuntu (which is on the nvme0n1p3 partition as lsblk said earlier) on /mnt, which means that doing

> ls /mnt/home/<user-name>/

will show the files in my home directory in Ubuntu! It’s all read-only, so no chance of corrupting anything. Also, typing all that is long, so we can create a symlink for ease of access:

> ln -s /mnt/home/<user-name>/ ~/ubuntu
> ls ~/ubuntu

Will give me the same output as the other ls command now. Neat, isn’t it?

Installing for real

After doing live testing for about a week, it was time to install Manjaro for real. Manjaro comes with a program called Calamares shipped in the ISO itself, so unless you are doing some manual resizing of partitions, you literally have to do nothing but follow the installation wizard.

Just make sure to read everything before you click start. For Manjaro, I created a new partition from nvme0n1p3 which was automatically labelled as nvme0n1p4 and got formatted with the BTRFS filesystem. And that was it! The GRUB menu got automatically updated, so I could choose between Manjaro and Ubuntu at boot time. Out of all the steps so far, this was the easiest one, I would say.

Bonus: Saying goodbye to Ubuntu

Once I had become more comfortable with Manjaro, I decided to remove Ubuntu completely. For this, my modus operandi was simple:

Deallocate the partition on which Ubuntu resided
Allocate the partition to Manjaro

There is a tool called GParted to do exactly that. It displays all the partitions on the computer and gives us the option to delete, resize or move them, among other things.

Using GParted

The only catch is that the currently active partition cannot be modified easily by GParted, so I had to do it by booting Manjaro from USB and installing GParted there. Since my actual Manjaro partition was not active then, I was able to resize it.

So my new lsblk is:

NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
nvme0n1     259:0    0 238.5G  0 disk
├─nvme0n1p1 259:1    0   925M  0 part /boot/efi
└─nvme0n1p4 259:2    0 237.6G  0 part /var/log
                                      /var/cache
                                      /home
                                      /

And there you have it! Everything except the boot sector with Manjaro.

[1] It turned out this partition indeed had the Windows boot manager. Since I no longer needed it, I gave it to Manjaro later

Thanks for reading The Stoic Programmer! Subscribe for free on my substack to receive new posts and support my work.

If you like what I am doing, this is a great way to show appreciation!

Buy me a coffee!

The Philosophy of Vim

Ash Ketchum — Tue, 21 Oct 2025 05:00:15 +0000

Vim. It was a name that inspired both awe and fear. No, I am not talking about this:

I meant this:

For a very, very long time, I was reluctant to use Vim. I thought it was for experts and those ultra-legend programmers of yore. If quitting Vim was supposedly enough of a meme, then actually doing anything in it would be the stuff of legends, right?

Well, last year, my friend started using it. And making some cool stuff. Things like nvim, nerd-tree, tmux, neofetch, etc, made it seem like he had ascended to the next level of programmer-kind. And then he showed it to me and said: “Learn and use Vim; it is very useful and easy. It is up to you, of course, but if you don’t, then I’ll silently judge you”.

Very nice friend, I agree. But his challenge to me was the catalyst that led me to adopt Vim to see if it really lived up to the hype, and I got a pleasant surprise when it proved to be less hard and more useful than I had thought earlier.

The Initial Days

I use an Ubuntu-based laptop. Consequently, firing up Vim was easy, and one of the first things I learnt was how to come out of it xD. I started following this tutorial from Ben Awad and made some good headway.

One of the greatest obstacles that I faced was the use of the keyboard to the complete exclusion of the mouse. I was not a touch-typist, and normal IDEs and text editors had made me heavily dependent on the mouse for anything other than typing code. So I had to unlearn my old instincts before developing new ones further.

Following the philosophy of “what gets measured gets managed”, I began practising touch typing on Monkeytype. It is not that I did not know of more websites that take a more structured approach to teach you how to touch type. In fact, I had tried them countless times before. But theoretically knowing which keys to type with which finger is very different from practically developing the muscle memory to do the right thing while typing. The structured examples seemed too artificial to me.

If you have ever been on Monkeytype, you know how it is. It basically throws a bunch of randomly generated text at you. There are a few settings that you can alter, but on the whole, it is a very minimalistic website. The whole point is to start typing whatever text they have given, and later, they will give the stats for it.

I like its minimalistic design and philosophy of quick feedback, which gives me a great way to know where to improve. The sentence words are mostly what you use every day, so it gives you a good example of what people normally type (certainly better than those contrived examples like “rerquiop” or “fjklsadffdsjaldfdjlsk”).

I practised using the normal word set containing only the lowercase English alphabet. Of course, for a programmer, that is not sufficient, but I observed that if my speed and accuracy on this subset of the keyboard increased, there was a sizable increase in them in general. Since then, I have also tried practising on an expanded word set, but for beginners, this is a good way to start.

It was not easy. One of the main hurdles encountered while unlearning something is that you temporarily become very slow in doing something you were used to doing fast. In this case, it's typing, of course. Before touch-typing, my average speed was around 20-25 WPM. After I began learning, it dropped to around 10 WPM, sometimes going as low as 1-2 WPM!

This is enough to demotivate the best of people, and I was no different. But what used to pick me up in these times was the stoic concept of control. I could not control when or if my typing would improve. What I can control, though, is how much practice I did. So I did what Cal Newport has described as ‘deliberate practice’ in his book So Good They Can’t Ignore You. That is, pushing myself a little more than what I normally do. If your speed is x WPM, then try to type at a speed slightly above that. I did this for half an hour daily and just typed normally the rest of the time. For that half an hour, though, it was just me and the keyboard. Nothing else mattered. I did 15-second sessions almost continuously for half an hour.

It is usually recommended to focus more on accuracy than speed, which is true to an extent. However, for the perfectionists among you, each wrongly typed character is an itch to be scratched, speed be damned. I found that rather than 100%, maintaining a 90%+ accuracy was a better way to get me off the ground. So, in that half an hour, I just typed on my keyboard, churning out what would be pages of random words (you should definitely read that book), typing for 15 seconds and then glancing through the feedback for 5 seconds, and then back to it. The exact details of feedback didn’t matter to me; I only wanted a 90%+ accuracy maintained as I tried to break past my WPM limit.

Slowly but surely, it started paying off. Over the course of a few months, I could see the change. My first milestone was equalling the speed that I had before I started touch typing. Soon enough, I surpassed that, and I am somewhere in the 55-60 WPM range at present (and above 95% accuracy), which is good enough for most purposes (Although I know there is still a lot of room for improvement). Now, it is more effort for me to type at 20-30 WPM, as my fingers are so attuned to the keyboard.

Learning by Customising

Parallely, I continued to learn the basic movements in Vim. It is a treasure trove, and I keep finding useful stuff in it even today (more than a year later). What I discovered here was the same problem as I had in learning touch typing. Beyond knowing what the combinations are, the artificial examples did little to develop my muscle memory when using them. I was still very prone to use the arrow keys for movement rather than j and k, and I would instinctively reach out for the mouse before remembering that it was useless here.

Then, I decided to learn Vim by doing something real in it. Fortunately, a very real-world example presented itself quite naturally: I set out to customise Vim to my liking.

I started tinkering with the .vimrc file. Interchanged the functions of 0 and ^. Made it display the file directory. Enabled line numbers and relative line numbering. Changed themes.

I could continue to customise Vim like this, but soon enough, I found something even better.

Enter NeoVim

The good friend who initially set me up on this path was not using vanilla Vim. What he was using was Vim ascended: NeoVim.

NeoVim is basically Vim with a lot of extra customizability and other cool stuff. First of all, instead of the basic VimScript that Vim uses for customisation, NeoVim uses Lua. You can imagine the increase in power of a full-fledged programming language with full support for functions, variables and the rest over just a normal scripting language limited to statements and expressions.

Which also means that you end up typing more, and in multiple files. I discovered some of the features, like multiple panes, marks, file tree, etc., because of tinkering around in NeoVim. I custom-designed my configuration and, in the process, became adept at handling the Vim bindings.

Since then, I have shifted to an out-of-the-box customisation given by LazyVim, as I felt that writing actual programs was more fun than changing plugins all the time. I know some of you would vehemently disagree on this point, but that is the viewpoint I have arrived at. Customising was a means to an end, to learn how to use Vim. Once I knew how to use it, I just settled with a good IDE and started aiming at higher things. Ships are safe in harbour, but that is not what ships are made for.

Edit on 2025-10-07: After installing Manjaro, I installed NeoVim on it, and this time, to understand the process and Lua better, I configured the plugins myself using the lazy package manager. I am definitely my own critic now!

Going Vim Beyond Vim: Vim Fever

Of course, I got what people call the ‘vim fever’. Once you get hooked to it, there is no going back; soon enough, you start seeing how to use the Vim movements everywhere.

Browser? You have to ‘C’ Vimium C. File manager? Move around with vifm. Desktop Manager? You can’t get better than i3. Want a full-fledged IDE with multiple project support? Replace VSC with NeoVim and tmux.

I started doing stuff even on my office laptop. We have to use a web code editor, which sadly does not have a Vim mode. But I found a cool extension that I could use to hook up the editor with VSCode on the laptop. And guess what I did next? I installed the Vim mode from the extension marketplace in VSC xD.

Takeaways

This whole learning Vim has been a whirlwind journey. Along the way, I learnt a lot of other things, and I am not referring just to touch-typing. Resilience, wanting to keep growing out of your comfort zone, and curiosity to keep knowing new things are some of the most important things not just for your professional career but for life in general. When faced with a challenge next time (and there will definitely be a next time; this is life), it can be useful to remember what Seneca said: Difficulties strengthen the mind, as labour does the body.

Interestingly, I would probably have seen this very differently just a few years back. Due to various reasons, I was in a very different mental state back then. I would have more likely than not taken what my friend initially told me in a negative way, then got discouraged when results did not immediately materialise, and not be able to give the intense focus required for learning to touch-type.

Indeed, I had tried touch typing earlier and never got used to it. Sticking to the more conventional websites which teach touch typing might have been a problem, as muscle memory cannot be “learned” without practice. But a deeper problem was my inability to focus for long periods of time.

This time, though, was ripe for me to tackle this problem. I had recently started incorporating Stoicism into my life (though it would still take me a few more months to discover that name), was relatively free in my final year of college, and had this friend as a neighbour in my hostel, who started delving into Vim in the summer holidays before our final year started. The confluence of all these at the right time in the right place shows that when the student is ready, the teacher appears.

Conclusion

There’s no substitute for Vim if you want to take your coding game to the next level. It took me a significant investment to learn Vim for practical use, but it has paid me back many times over in my career. Now, I am at the point where I cannot imagine life without it, somewhat like this guy.

So, should you invest your time in learning Vim? I will let Marcus Aurelius take this one:

Waste no more time arguing what a good programmer should be. Be one.

Thanks for reading this! Let me know what you think in the comments.

For more content like this, visit The Stoic Programmer!