It’s not just for aesthetics (though it does look cool 😎). It helps me track:

• When the script was created
• Who wrote it (me 👋)
• And when it was last modified

Manually updating that info? Nah. Too tedious.

So I built a lightweight CLI tool called headerize that automatically adds or updates headers in my .sh or .py files.

Let me walk you through how I did it — and how you can too.

⚡️ Why Automate Headers?

If you write a lot of scripts, a standardized header saves time and avoids confusion. Here’s what my headers look like:

#!/bin/bash

#
#       ███╗   ██╗██╗██╗  ██╗ █████╗ ██████╗ ███████╗
#       ████╗  ██║██║██║  ██║██╔══██╗██╔══██╗██╔════╝
#       ██╔██╗ ██║██║███████║███████║██████╔╝███████╗
#       ██║╚██╗██║██║██╔══██║██╔══██║██╔══██╗╚════██║
#       ██║ ╚████║██║██║  ██║██║  ██║██║  ██║███████║
#       ╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝
#       DRAFTED BY [https://nih.ar] ON 10-04-2021.
#       SOURCE [myscript.sh] LAST MODIFIED ON 06-04-2025.
#

Now, imagine doing that manually every time, and updating the date whenever you tweak something. This tool does it all — and even smartly preserves the original "drafted" date.

🧪 Meet headerize

This is a Bash script that:

• Adds a full header if one doesn't exist
• Updates the "last modified" date if a header is already present
• Works with .sh, .py, and any other files you want to include

Let’s set it up.

Step 1: Create the headerize Script

📁 Location: I like to keep my CLI tools in ~/bin, but you can place it wherever you like.

mkdir -p ~/bin
touch ~/bin/headerize
chmod +x ~/bin/headerize

Main Script:

#!/bin/bash

website="https://nih.ar"
today=$(date +"%d-%m-%Y")
file="$1"

if [[ "${file##*.}" == "py" ]]; then
    cbang="#!/usr/bin/env python3"
else
    cbang="#!/bin/bash"
fi

heading() {
    cat <<EOF > "$file"
$cbang

#
#       ███╗   ██╗██╗██╗  ██╗ █████╗ ██████╗ ███████╗
#       ████╗  ██║██║██║  ██║██╔══██╗██╔══██╗██╔════╝
#       ██╔██╗ ██║██║███████║███████║██████╔╝███████╗
#       ██║╚██╗██║██║██╔══██║██╔══██║██╔══██╗╚════██║
#       ██║ ╚████║██║██║  ██║██║  ██║██║  ██║███████║
#       ╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝
#       DRAFTED BY [$website] ON $today.
#       SOURCE [$file] LAST MODIFIED ON $today.
#
EOF
}

if [ -s "$file" ]; then
    line10=$(sed -n 10p "$file")

    if [[ "${line10:20:14}" != "$website" ]]; then
        # No header — prepend new header
        tmp="$(mktemp)"
        heading
        cat "$file" >> "$tmp"
        mv "$tmp" "$file"
    else
        # Header exists — just update the last modified line
        modline="#       SOURCE [$file] LAST MODIFIED ON $today."
        sed -i "11s|.*|$modline|" "$file"
    fi
else
    heading
fi

echo "" >> "$file"

Step 2: Add It to Your PATH

If ~/bin isn’t in your path yet, add this to your .bashrc or .zshrc:

export PATH="$HOME/bin:$PATH"

Then reload your shell:

source ~/.bashrc   # or ~/.zshrc

Now you can run it from anywhere:

headerize myscript.sh

Bonus: Add an Alias

alias h='headerize'

Then just:

h script.sh

Real World Usage

Whenever I start a new script or edit an existing one, I just run:

headerize filename.sh

If it's a new file → it adds a full header. If it's an old file → it updates the "Last Modified" line only. Creation date stays untouched. Clean and reliable.

That's It

I like building tools that do one job well. This little script has saved me countless tiny moments — and made my codebase feel more personal and professional.

Feel free to fork it, tweak it, or drop me a line if you improve it.

Why Use Aliases?

Aliases are shortcuts for longer commands. They save time, reduce typing errors, and make your workflow smoother. Here's a collection of useful aliases to streamline your command line experience.

Basic Aliases

1. Clearing the Terminal:

alias c='clear'

A simple alias to clear the terminal screen quickly.

2. Git Shortcuts:

alias g='git'

Shorten git commands to a single letter for rapid version control operations.

3. List Directory Contents:

alias l='exa -lars date'

Use exa instead of ls for enhanced directory listing with sorting by date.

4. System Information:

alias nf='neofetch'

Quickly display system information with Neofetch.

File and Directory Management

5. Move Files to Temporary Directory:

alias rmv='mv -t /tmp '

Safely move files to the /tmp directory instead of deleting them.

6. Neovim Shortcuts:

alias v='nvim'
alias vi='nvim'

Open files with Neovim using v or vi.

7. Create Directories with Parents:

alias mkdir='mkdir -pv'

Create directories with all necessary parent directories.

8. Python Environment Activation:

alias pyenv='source /home/web/pyenv/bin/activate'

Quickly activate your Python virtual environment.

User and System Commands

9. Switch to Web User:

alias web='su - web'

Switch to the web user with a single command.

10. Edit Files with Sudo:

alias svi='sudo vi'

Edit files with root privileges using Neovim.

11. Systemctl Shortcuts:

alias ss='sudo systemctl'

Manage system services easily with systemctl.

12. Python 3 Shortcut:

alias p='python3'

Run Python 3 scripts without typing the full command.

Directory Navigation

Navigating directories can be tedious. These aliases help you move up directories quickly:

13. Go Up One Level:

alias ..='cd ..'

14. Go Up Two Levels:

alias ...='cd ../../../'

15. Go Up Three Levels:

alias ....='cd ../../../../'

16. Go Up Four Levels:

alias .4='cd ../../../../'

17. Go Up Five Levels:

alias .5='cd ../../../../..'

Archive Extraction

Extracting different types of archives can be cumbersome. This function makes it easier:

18. Extract Files:

ex () {
  if [ -f $1 ] ; then
    case $1 in
      *.tar.bz2)   tar xjf $1   ;;
      *.tar.gz)    tar xzf $1   ;;
      *.bz2)       bunzip2 $1   ;;
      *.rar)       unrar x $1   ;;
      *.gz)        gunzip $1    ;;
      *.tar)       tar xf $1    ;;
      *.tbz2)      tar xjf $1   ;;
      *.tgz)       tar xzf $1   ;;
      *.zip)       unzip $1     ;;
      *.Z)         uncompress $1;;
      *.7z)        7z x $1      ;;
      *.deb)       ar x $1      ;;
      *.tar.xz)    tar xf $1    ;;
      *.tar.zst)   unzstd $1    ;;      
      *)           echo "'$1' cannot be extracted via ex()" ;;
    esac
  else
    echo "'$1' is not a valid file"
  fi
}

This function detects the file type and uses the appropriate command to extract it. Simply call ex <file> to extract your archives.

Conclusion

These aliases and functions can drastically improve your command line efficiency. Customize them to fit your workflow and enjoy a more streamlined and productive terminal experience. Happy aliasing!

My personal aliases : GITLAB alias

By implementing these aliases, you can make your command line interactions faster and more efficient. Try them out, modify them to your liking, and share your favorite aliases in the comments!

Why Harden Your SSH Server?

SSH is a widely used protocol for securely accessing and managing servers. However, if not properly configured, it can become a target for brute force attacks, unauthorized access, and other security threats. Hardening your SSH server minimizes these risks and fortifies your server against potential intrusions.

Step-by-Step Guide to Hardening SSH

1. Update SSH and System Packages

Keeping your system and SSH server up to date is the first step in ensuring security. Regular updates include patches for known vulnerabilities.

sudo apt-get update && sudo apt-get upgrade

2. Edit SSH Configuration

Open the SSH daemon configuration file to make necessary adjustments.

sudo nano /etc/ssh/sshd_config

3. Change the Default Port

Changing the default SSH port from 22 to a non-standard port reduces the risk of automated attacks.

Port 2222

Don’t forget to update your firewall rules to allow traffic on the new port.

4. Disable Root Login

Allowing root login via SSH poses a significant security risk. Disable it to prevent unauthorized root access.

PermitRootLogin no

5. Use SSH Protocol 2 Only

SSH protocol 2 is more secure than version 1. Ensure only protocol 2 is used.

Protocol 2

6. Limit User Logins

Restrict SSH access to specific users or groups to minimize potential attack vectors.

AllowUsers user1 user2

Or restrict by groups:

AllowGroups sshusers

7. Disable Password Authentication

Password-based logins are vulnerable to brute-force attacks. Use key-based authentication instead.

PasswordAuthentication no

8. Enable Public Key Authentication

Ensure public key authentication is enabled for secure access.

PubkeyAuthentication yes

9. Configure Idle Timeout

Set a timeout interval for idle sessions to automatically log out, reducing the risk of unauthorized access.

ClientAliveInterval 300
ClientAliveCountMax 2

10. Disable Empty Passwords

Ensure accounts with empty passwords cannot log in.

PermitEmptyPasswords no

11. Disable X11 Forwarding

If X11 forwarding is not required, disable it to close another potential attack vector.

X11Forwarding no

12. Use Strong Encryption Algorithms

Configure SSH to use only strong ciphers, MACs, and key exchange algorithms.

Ciphers aes256-ctr,aes192-ctr,aes128-ctr
MACs hmac-sha2-512,hmac-sha2-256
KexAlgorithms diffie-hellman-group-exchange-sha256

13. Limit Login Attempts

Reduce the risk of brute force attacks by limiting the number of login attempts.

MaxAuthTries 3

14. Log and Monitor SSH Access

Enable logging and regularly monitor logs for any suspicious activity.

sudo grep sshd /var/log/auth.log

15. Install Fail2Ban

Fail2Ban helps protect your server from brute force attacks by banning IP addresses after a certain number of failed login attempts.

sudo apt-get install fail2ban

Configure Fail2Ban for SSH:

sudo nano /etc/fail2ban/jail.local

Add the following to the file:

[sshd]
enabled = true
port = 2222
filter = sshd
logpath = /var/log/auth.log
maxretry = 3

16. Restart SSH Service

After making these changes, restart the SSH service to apply them.

sudo systemctl restart sshd

Conclusion

By following these steps, you can significantly enhance the security of your SSH server. Regularly review and update your SSH configuration to keep up with the latest security practices and protect your server from emerging threats. Secure your SSH today and sleep better knowing your server is well-protected.

By implementing these hardening measures, you'll fortify your SSH server against a wide array of threats, ensuring a more secure and resilient server environment. Stay vigilant and proactive in maintaining your server's security posture.

Setting up a new server can be a tedious and time-consuming task, involving multiple steps such as updating software, installing packages, configuring users, and more. To streamline this process, we've created a bash script that automates these tasks, allowing you to set up a new server quickly and effortlessly.

echo "Automated Server Setup Script"

echo "Enter new hostname for the server:"
read host_name

echo "Enter new username for user creation"
read user_name

echo "Server update started"
sleep 2

echo "sudo apt-get update -y"
sudo apt-get update -y
echo "update date"
echo "sudo apt-get upgrade -y"
sleep 5

sudo apt-get dist-upgrade -y
sudo "upgrade done"
echo "sudo apt-get dist-upgrade -y"
sleep 5

sudo apt-get dist-upgrade -y
echo "dist upgrade done"
echo "installing software"
sleep 5

sudo apt-get install zsh neovim exa zsh-syntax-highlighting zsh-autosuggestions python3-venv python3-pip neofetch git nginx certbot python3-certbot-nginx -y
echo "software installed"
echo "creating directories and moving files"
sleep 5

sudo mkdir -p ~/.config/{nvim,zsh,.local/share,.cache}
sudo mv init.vim ~/.config/nvim/
sudo mv .zshrc ~/.config/zsh/
sudo mv .zprofile ~/
echo "Directories created and file moved"
echo "Changing shell to zsh"
sleep 5

sudo chsh -s /bin/zsh
sudo source .zprofile
echo "Shell changed"
echo "adding user $user_name"
sleep 5

sudo useradd -m -s /bin/zsh $user_name && sudo passwd
sudo usermod -aG sudo $user_name
sudo cp -r .ssh/ .zprofile .config /home/$user_name/
cd /home/$user_name
sudo chown -R $user_name:$user_name .config .zprofile .zshrc .ssh
echo "$user_name user created"
echo "setup finished"
echo "changing hostname"
sudo hostnamectl set-hostname $host_name
echo "Please update sshd"
sleep 5

sudo nvim /etc/ssh/sshd_config
echo "Finished sshd configuration"
echo "restarting nginx sshd"
sleep 5

sudo systemctl restart sshd
sudo systemctl enable nginx
sudo systemctl start nginx
echo "restarted all service"
sleep 5

sudo zsh

Source Code: gitlab

How to Use the Script

To use the script, follow these simple steps:

1. Copy the script into a new file on your server, for example, setup.sh.
2. Make the script executable by running chmod +x setup.sh.
3. Run the script with ./setup.sh.
4. Follow the prompts to enter the new hostname and username for user creation.
5. Sit back and relax while the script automates the server setup process.

Conclusion

With the automated server setup script, you can significantly reduce the time and effort required to set up a new server. By automating tasks such as software installation, user creation, and configuration, you can focus on more important aspects of your project without worrying about tedious setup processes. Give it a try and see how much time and effort you can save!

"Feel free to customize this script further according to your specific needs, such as adding additional software packages or configuring different settings. Happy automating!"

1. Create a Bootable Disk

Begin by creating a bootable disk with the Arch Linux ISO. Use the lsblk command to identify your USB drive, then use dd to write the ISO to the disk:

lsblk
dd bs=4M if=path/to/archlinux-version-x86_64.iso of=/dev/disk/by-id/usb-My_flash_drive conv=fsync oflag=direct status=progress

2. Connect to the Internet

For wireless connection, use iwctl. List available networks, then connect to your desired network:

iwctl
station device get-networks
iwctl --passphrase passphrase station device connect SSID

3. Clear/Format Disk

Clear and format your disk using fdisk:

fdisk /dev/sda
g   # create new gpt label
p   # print the partition table
n   # create a new partition
d   # delete a partition
q   # quit without saving changes
w   # write the new partition table and exit

Format disk type:

mkfs.fat -F32 /dev/sda1
mkfs.ext4 /dev/sda2

4. Mounting and File Structure

Mount your partitions and create necessary directories:

mount /dev/sda2 /mnt
mkdir -p /mnt/{home,data,etc}
mount /dev/sdb1 /mnt/data

5. Basic Setup

Generate fstab and chroot into the new system:

genfstab -U -p /mnt >> /mnt/etc/fstab
pacstrap -i /mnt base
arch-chroot /mnt

6. Install Software

Install necessary software packages:

pacman -S linux-lts linux-lts-headers base-devel linux-firmware vim networkmanager wpa_supplicant wireless_tools netctl dialog nvidia-lts nvidia-utils grub efibootmgr os-prober mtools dosfstools intel-ucode xorg-server xorg neofetch pulseaudio pamixer termite dolphin git vlc vifm i3

7. System Settings

Set up time and language:

ln -sf /usr/share/zoneinfo/Asia/Kolkata > /etc/localtime
hwclock --systohc
vim /etc/locale.gen   # uncomment desired locale
locale-gen
echo "LANG=en_US.UTF-8" > /etc/locale.conf

Initiate Linux:

mkinitcpio -p linux-lts

8. User Addition

Create a new user and enable them as admin:

useradd -m -g users -G wheel myusername
passwd myusername
visudo   # enable wheel group

9. Install Grub

For UEFI systems:

mkdir /boot/efi
mount /dev/sda1 /boot/efi
grub-install --target=x86_64-efi --bootloader-id=grub --recheck
grub-mkconfig -o /boot/grub/grub.cfg

10. Hostname and Host

Set hostname and hosts:

echo "mySystemName" > /etc/hostname
echo -e "127.0.0.1\tlocalhost\n::1\tlocalhost\n127.0.1.1\tmySystemName.localdomain\tmySystemName" > /etc/hosts

11. Enable Network

Enable NetworkManager:

systemctl enable NetworkManager

12. Reboot

Reboot your system:

reboot

13. After Installation

After reboot, connect to WiFi:

nmcli device wifi connect SSID password "password"

14. Additional Software Installation

Install additional software packages using yay:

git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si
yay -S brave optimus-manager optimus-manager-qt code zsh vim vi unzip zsh-you-should-use zsh-syntax-highlighting wget pamixer libreoffice-still youtube-dl opusfile opus-tools libopusenc opus cmus openssh

15. Vim Plug

Install Vim Plug for neovim:

sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'

16. Install FiraCode

Download and install FiraCode:

mkdir /usr/share/fonts/firacode
# Copy FiraCode.zip to this directory
fc-cache -vf

17. Additional Configurations

Configure autologin for tty1:

sudo systemctl edit [email protected]
# Paste the following:
#[Service]
#ExecStart=
#ExecStart=-/usr/bin/agetty --autologin username --noclear %I $TERM
#Type=idle

18. Grub Configuration

Modify Grub timeout:

vi /etc/default/grub
GRUB_TIMEOUT=0
sudo grub-mkconfig -o /boot/grub/grub.cfg

19. Timezone Configuration

Set timezone:

sudo timedatectl set-timezone Asia/Kolkata

20. Theme Installation

Install theme:

cd /usr/share/themes
# Copy Material-Black-/usr/share/themes to this directory
lxappearance

21. Additional Software

Install rclone:

yay -S rclone
rclone sync your_folder cloud:your_folder

Congratulations! You've successfully installed Arch Linux with dwm and configured your system. Enjoy your customized and efficient Linux setup!

Why Opt for the Gemini Protocol?

Gemini capsules, or Gemini webpages, are lightweight, minimal, and demand minimal resources. They can seamlessly coexist with your existing websites, utilizing port 1965 by default while your web server operates on ports 80 or 443. Exploring this alternative protocol opens avenues for serving data and blogs differently. Accessing Gemini URLs (e.g., gemini://example.org) requires a Gemini client such as Amfora, Lagrange, or Elpher.

1. Creating a Gemini User

For security and cleanliness, it's advisable to establish a separate Gemini user:

useradd -m -s /bin/bash gemini

Then, switch to the Gemini user:

su -l gemini

To create and serve a Gemini capsule, follow these three basic steps:

1. Content: These are the webpages within your capsule.
2. TLS Certificate: Gemini necessitates an encrypted connection.
3. Gemini Server: This program makes your capsule available, akin to Nginx for HTTP.

As the Gemini user, organize three directories to streamline the process:

mkdir -p ~/gemini/{content,certificate,server}

2. Content

This directory will house your capsule files. Gemini employs text/gemini markup (similar to Markdown). Create a gemini file within the content directory:

nano gemini/content/index.gmi

Add your desired content to this Gemini capsule file:

# This is a Sample Gemini page
## With header 1 and header 2
And a short paragraph like this.
=> /index.gmi Link to the same page

3. TLS Certificate

Navigate to the certificate directory and generate a TLS certificate using OpenSSL:

cd ~/gemini/certificate/
openssl req -new -subj "/CN=example.org" -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -days 3650 -nodes -out cert.pem -keyout key.pem

4. Gemini Server

Download and prepare the server. We'll use the Agate server, a simple Gemini server written in Rust:

cd ~/gemini/server
wget https://github.com/mbrubeck/agate/releases/download/v3.1.0/agate.x86_64-unknown-linux-gnu.gz
gunzip agate.x86_64-unknown-linux-gnu.gz
mv agate.x86_64-unknown-linux-gnu agate-server
chmod +x agate-server

5. Create a System Service

Switch back to root to create a systemd service:

nano /etc/systemd/system/agate.service

Customize the highlighted text to your setup:

[Unit]
Description=agate
After=network.target

[Service]
User=gemini
Type=simple
ExecStart=/home/gemini/gemini/server/agate-server --content /home/gemini/gemini/content --certs /home/gemini/gemini/certificate/ --hostname example.org --lang en-US

[Install]
WantedBy=default.target

Enable and start the Agate server:

systemctl enable agate
systemctl start agate

6. Firewall

If you're running a firewall, remember to open port 1965:

ufw allow 1965

Finalization

With everything set up, your server should be running. Access your Gemini capsule via any Gemini client with a URL like gemini://example.org.

For reference, check out a sample Gemini site: gemini://gemini.circumlunar.space.

Enjoy your first Gemini capsule!

For information about how to write in "gemtext" the markup language in Gemini, see this site: https://gemini.circumlunar.space/docs/gemtext.gmi. As you might guess, it also has an analogous gemini capsule here: gemini://gemini.circumlunar.space/docs/gemtext.gmi

My gemini capsule: https://portal.mozz.us/gemini/nih.ar/

This ariticle is also available at landchad

Enter the XDG Base Directory specification, courtesy of freedesktop. This nifty set of guidelines offers a solution to our clutter conundrum. Here's a quick rundown of how I keep my digital abode squeaky clean using these specs:

Basic directory structure

First things first, let's set up the main environmental variables:

    export XDG_CONFIG_HOME="$HOME/.config"
    export XDG_CACHE_HOME="$HOME/.cache"
    export XDG_DATA_HOME="$HOME/.local/share"

These variables dictate where our config, cache, and data are stored. Pop these babies into your RC files (think bashrc/zshrc/other shells RC), or go big and make them global environmental variables.

Reconfigure the paths

Now, all paths set in these environment variables need to be absolute. Think of it as giving your configs a new address – instead of .zshrc chilling in your home path, it's now kicking back in /.config/zsh/zshrc.

Define Application-Level XDG Configs

Here are a few XDG specs I swear by for some of my go-to applications:

    export CARGO_HOME="$XDG_DATA_HOME/cargo"
    export XMONAD_CONFIG_HOME="$XDG_CONFIG_HOME/xmonad"
    export XMONAD_DATA_HOME="$XDG_CONFIG_HOME/xmonad"
    export XMONAD_DATA_HOME="$XDG_CONFIG_HOME/xmonad"
    export XMONAD_CACHE_HOME="$XDG_CONFIG_HOME/xmonad"
    export RUSTUP_HOME="$XDG_DATA_HOME/rustup"
    export XAUTHORITY="$XDG_RUNTIME_DIR/Xauthority"
    export XINITRC="$XDG_CONFIG_HOME/X11/xinitrc"
    export XSERVERRC="$XDG_CONFIG_HOME/X11/xserverrc"
    export HISTFILE="$XDG_DATA_HOME/bash/history"
    export GNUPGHOME="$XDG_CONFIG_HOME/gnupg"

Wrapping Up

If you want to check if your application support XDG base specifications, please go through this arch wiki article.

And voilà! With these tweaks in place, my home path is now as tidy as Marie Kondo's sock drawer. So, the next time you peek into your digital dwelling, may you be greeted by a sight as refreshing as a clean slate. 🏠✨

That's all. After doing all above, this is what my home looks like :

    [nihar@fybox ~]$ ls -a | wc -l
    12

However, if you're interested in maintaining a mirrored copy of GitLab in GitHub or vice versa, GitHub provides a specific article for that purpose.

If your aim is to keep GitHub and GitLab repositories independent, follow these guidelines:

1. Adding SSH Keys to Your Local Machine (Optional Step)

While you can use the same keys for each Git source, I prefer using different keys for different sources. Generate unique SSH keys for Codeberg, GitLab, and GitHub:

ssh-keygen -t rsa -C "[email protected]" -f ~/.ssh/id_rsa_codeberg
ssh-keygen -t rsa -C "[email protected]" -f ~/.ssh/id_rsa_gitlab 
ssh-keygen -t rsa -C "[email protected]" -f ~/.ssh/id_rsa_github

Add the public keys to Codeberg, GitLab, and GitHub:

Add ~/.ssh/id_rsa_codeberg.pub to Codeberg SSH keys.
Add ~/.ssh/id_rsa_gitlab.pub to GitLab SSH keys.
Add ~/.ssh/id_rsa_github.pub to GitHub SSH keys.

Register the keys on your local machine:

ssh-add ~/.ssh/id_rsa_codeberg
ssh-add ~/.ssh/id_rsa_github
ssh-add ~/.ssh/id_rsa_gitlab

2. Editing ~/.ssh/config

Edit the ~/.ssh/config file with the following content:

Host codeberg.org
    HostName codeberg.org
    User git
    IdentityFile ~/.ssh/id_rsa_codeberg
Host gitlab.com
    HostName gitlab.com
    User git
    IdentityFile ~/.ssh/id_rsa_gitlab
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_github

3. Configuring Repositories and Remotes

Clone the original repository from GitLab/GitHub/Codeberg to your local machine:

git clone [email protected]:username/repository_name.git

Create a remote instance of the same:

cd repository_name
git remote set-url origin --add [email protected]:username/repository_name.git
git remote set-url origin --add [email protected]:username/repository_name.git

4. Checking Remote Repositories

To check all the remotes for the repository, run:

git remote -v

The command should return something like:

origin  https://github.com/username/repository_name.git (fetch)
origin  https://github.com/username/repository_name.git (push)
origin  https://gitlab.com/username/repository_name.git (push)
origin  https://codeberg.org/username/repository_name.git (push)

Now you can simply use git push, and it will push changes to all remotes.

Yet, amidst this varied landscape, one fundamental principle remains paramount: the essence of programming lies in problem-solving. The ultimate goal is not merely to code in a particular language, but rather to tackle challenges swiftly and effectively.

In today's tech landscape, there's a growing trend towards language-centricity among developers. However, perhaps it's time to reconsider this approach. Instead of rigidly adhering to one language, let's adopt a more pragmatic stance. Let's choose the language that best suits the task at hand, enabling us to solve problems with speed and efficiency.

After all, in the ever-evolving realm of technology, adaptability is key. So, let's embrace the versatility of programming languages and harness their power to overcome obstacles, one line of code at a time.

Back in the 1980s and 1990s, when hardware resources were scarce and every byte counted, developers were forced to adhere to this principle out of necessity. Games like Dangerous Dave were marvels of efficiency, squeezing maximum enjoyment out of a mere 0.21 MB of space. With floppy disks as the pinnacle of portable storage, there was no room for excess. And yet, despite these limitations, software of that era was remarkably efficient and effective.

C, with its low-level capabilities and close relationship with system hardware, was the language of choice for many developers. Even after four decades, its simplicity and power endure, making it the go-to language for projects where performance and reliability are paramount.

The essence of DOTADIW lies in writing code that is minimal, understandable, and focused. Each component should have a clear purpose, with no extraneous features or functionality. By adhering to this principle, developers can create software that is not only easier to maintain and debug but also more reliable and efficient.

In a world where complexity often reigns supreme, embracing the simplicity of DOTADIW can be a breath of fresh air. Whether you're building a small utility or a large-scale application, remember the timeless wisdom of doing one thing and doing it well.

However, a couple of months ago, I decided to delve deeper into the world of Vim. Fast forward to today, and Neovim has become my default text editor. Interestingly, my muscle memory now instinctively reaches for hjkl keys even when using other text editors like Sublime Text.

With most of my time now spent in the terminal, I've compiled a handy cheat sheet of Vim commands that I've picked up along the way.

Basic Commands in VIM

Modes of Vim:

• Normal mode: Pressing the escape key brings you to normal mode.
• Insert mode: Use i, a, s, o, or similar to enter insert mode.
• Visual mode: v for visual, shift+v for visual-line, cntr+v for visual block.
• Command mode: Type : or / to show commands at the bottom of the Vim screen.
• Replace mode: r for replacing a single character, R for replacing multiple characters.

Navigation in Vim:

• h: Move left
• j: Move down
• k: Move up
• l: Move right
• gg: Go to the top
• G: Go to the bottom
• w: Move to the beginning of the next word
• b: Move to the beginning of the previous word
• f: Find the next occurrence of a character
• /: Search forward
• ?: Search backward
• n: Repeat the last search in the same direction
• 0: Move to the beginning of the line
• ^: Move to the first non-blank character of the line
• $: Move to the end of the line

Operations in Vim:

• i: Insert at the current position
• a: Append after the current position
• o: Insert a new line below the current line
• O: Insert a new line above the current line
• u: Undo
• ctrl+r: Redo
• x: Delete a character
• dd: Delete the current line
• yy: Yank the current line
• p: Paste

Registers, Macros, Bookmark, Buffers in VIM

Bookmark:

• ma: Set a bookmark named 'a'
• `a: Move to the location of bookmark 'a'
• :marks: List all bookmarks
• :delmarks a: Delete bookmark 'a'

Macros:

• qa: Start recording a macro named 'a'
• Enter your Vim actions
• q: Stop recording the macro
• @a: Play the recorded macro 'a'

Registers:

• "aY: Yank the current line in register 'a'
• "ap: Paste from register 'a'

Buffers:

• :ls: List all buffers
• :badd : Add a file to a new buffer
• :b2: Switch to the second buffer
• :bn: Move to the next buffer
• :bp: Move to the previous buffer
• :bd: Delete the current buffer

Tab and Windows:

• :vs: Vertical split
• :sp: Horizontal split
• :vs file: Open a file in a vertical split
• :tabnew: Add a new tab
• :tabclose: Close the current tab
• :tabnext: Move to the next tab
• ctrl+w +: Increase window size

By combining these commands creatively, Vim's power truly shines. And while this list only scratches the surface of Vim's capabilities, it's a testament to the efficiency and versatility of this legendary text editor.

Writing the inaugural post for a blog can be quite the ordeal, don't you think? After much contemplation and a fair bit of googling, I've come to the realization that there's no one-size-fits-all approach to kick-starting a blog. However, I've settled on the idea that a simple and succinct introduction might just do the trick. So, here it is:

I'm a hobbyist developer, and this blog is my canvas for expressing my passion. My personal mission in launching this platform is to hone my writing skills while sharing insights into my hobby with you.

Lastly, a heartfelt thank you to each and every one of you who has taken the time to visit and peruse my website. Your presence means the world to me, and I'm grateful for every pair of eyes that grace these pages. Suggestions and feedback are always welcomed with open arms.

Once again, thank you for stopping by, and I hope you enjoy the journey ahead with me.