DEV Community: Anit Jha

Customize Grub Theme Fedora

Anit Jha — Sun, 07 Jan 2024 20:16:05 +0000

Why Am I Writing This?

Today, I decided to switch up my Fedora GRUB2 theme. After sifting through tutorial after tutorial and restarting my computer a whopping 12 times, I think I've finally cracked the code on the correct way to do it. So let's dive right in! ✈️✈️

Things You Would Need

Before we start, let's ensure you've got everything handy:

Follow Instructions Carefully: No skipping steps allowed! ⚠️
Grab a Grub Theme: You'll need one from Gnome-Look. Surprise, surprise!
Familiarity with Command Line: Get a bit cozy with it.
Patience is Key: I'll walk you through each step in detail.

Step 0: Try using grub-customizer first

If that does not work then ⬇️⬇️⬇️

Step 1: Downloading a Grub Theme

First things first, head to Gnome-Look and pick a theme you fancy. Most likely, it'll be in an archive file.

Once downloaded, double-click to extract it.

Now pop open the terminal and write

sudo cp -r /path/to/extracted/theme /boot/grub2/themes

Replace /path/to/extracted/theme with the actual path to the extracted theme folder.

This command will copy the entire extracted theme folder to the /boot/grub2/themes directory using the sudo command for administrative privileges.

It's important to note that when using the command line, you need to specify the correct paths to ensure the theme folder is a accurately copied to the designated GRUB themes directory. Adjust the path accordingly based on where the theme is extracted.

Congrats! You've aced a major step. Now, just stick to my commands religiously.

Step 2: Editing the Grub Config

Time to play with some configs! Open the terminal and access /etc/default/grub using your favorite editor:

sudo nano /etc/default/grub

Your file should mirror this:

GRUB_TIMEOUT="10"
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT="saved"
GRUB_DISABLE_SUBMENU="true"
#GRUB_TERMINAL_OUTPUT="console"
GRUB_CMDLINE_LINUX="rhgb quiet"
GRUB_DISABLE_RECOVERY="true"
GRUB_ENABLE_BLSCFG="true"

export GRUB_COLOR_NORMAL="light-gray/black"
export GRUB_COLOR_HIGHLIGHT="magenta/black"
GRUB_THEME="/boot/grub2/themes/<YOUR-THEME>/theme.txt"

Simply Replace <your-theme> with your actual theme folder name

This file controls Fedora's grub.cfg generation, which is crucial for booting.

Step 3: Generating the Grub.Cfg File

Almost there! Run this commands:

sudo grub2-mkconfig -o /boot/grub2/grub.cfg

🚫🚫 Don't run this command sudo grub2-mkconfig -o /boot/efi/EFI/fedora/grub.cfg because this file is meant not to be touched after fedora 33

Reboot

You're Welcome If It Helped You 😎

Remember, it's all about patience and precision! If you're having a blast customizing your Fedora GRUB2, then my mission here is accomplished. Happy theming!

Elevate Your Windows PowerShell: My Personal Customization Guide

Anit Jha — Sun, 15 Oct 2023 15:14:00 +0000

Hi 👋🏻! Today I'm going to talk about how I setup windows PowerShell on my windows machine. As a developer, I think having a nice-looking terminal and some good useful tools can push towards being a little more productive. Read more blogs at My website.

Terminal Application

There are many terminal applications for windows, but my favorite is the prepackaged Windows Terminal App.
It is:

Visually Appealing
Highly customizable
Tabs Support.

Customizing the Appearance of Windows Terminal

First and foremost, set the Windows Terminal as your default Terminal App.

Access your settings with a quick Ctrl + , shortcut. Within the settings menu, find the option to change the default Terminal Application for your machine, and select windows terminal from the dropdown.

With your default terminal all sorted! 💫

Now it's time to give it a fresh look.
I'm all about that cool acrylic aesthetic in my Terminal App.

Open settings 👉, then, on the left-hand-side menu, head to 👉 Profiles, and within that, navigate to 👉 Defaults. Inside the default settings, you'll find 👉 Appearance.
Now, here's where you can tweak the theme to match your style.
I, for one, love to throw in a Background Image and give the Terminal a bit of blur for that extra flair.

Installing Scoop

Scoop is your go-to Windows package manager, much like Ubuntu's apt and Fedora's dnf. It simplifies the management of apps and binaries on your Windows machine. With a single command, you can easily update, install, or delete binaries, eliminating the need for manual configuration of environment variables and paths. Scoop offers various buckets filled with a wide range of apps, and it even makes font installation a breeze.

Before we start customizing the prompt I recommend installing the SCOOP package manager for windows, It will make our work very easy moving froward.

In your terminal run these commands one by one:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex

This will install SCOOP in your system.

NERD Font Installation with Scoop

Before customizing your prompt with glyphs and symbols like the GitHub or folder icons, you'll need to install a NERD font. Regular fonts just can't handle these unique characters, but the NERD fonts have got you covered. You can explore other nerd fonts at (https://nerdfonts.com).

My personal favorite NERD font is Cascadia-Code, and here's where the Scoop magic comes into play. If you've ever attempted to install a custom font, you're aware that it often involves multiple steps. Scoop simplifies the process to just one command. Here's how it's done:

Start by adding the NERD Font bucket to your Scoop setup:

scoop bucket add nerd-fonts

Next, install the Cascadia Code NERD font with this command:

scoop install Cascadia-Code

This straightforward process will add the Cascadia-Code font to your system, making it available for you to use.

Changing Your Terminal Font

Now that you have the NERD font installed, it's time to change your terminal font to Cascadia-Code. Here's how to do it:

Navigate to your terminal's settings.
Look for "Defaults" and then "Appearance."
In the "Font Face" option, select "Cascadia-Code."

With these simple steps, you'll have your terminal decked out with the NERD font of your choice, ready to make your prompt uniquely yours.

Customizing the prompt using OH-MY-POSH.

Oh-My-Posh, is my favourite tool for making my prompt look super cool. It gives my terminal a unique, fancy style. Oh-My-Posh makes it super easy. A nice prompt makes a dev life easier.

Getting Oh-My-Posh Installed

Te main bucket is already added, you can skip this if you want...

scoop bucket add main

Get yourself oh-my-posh.

scoop install oh-my-posh

Now that oh-my-posh is installed its time to configure our windows profile script.

Setting Up Your PowerShell Profile

PowerShell profile, it's like a special script that runs whenever you start up PowerShell. You can do all sorts of things with it to make your PowerShell experience more awesome. You can add shortcuts, like nicknames, and extra tools that load up when you start PowerShell. Plus, you can make your own special functions to fit the way you work. It's like a power-up for PowerShell!

To open your PowerShell profile in Notepad, just type this command:

notepad $profile

If you come across an error, don't worry! You can fix it with this command:

New-Item -Path $PROFILE -Type File -Force

Give it a try, and then open your profile again. If you haven't made any changes before, your profile will be empty.

To make your prompt look like mine, add this line to your profile and save it:

oh-my-posh init pwsh --config "C:\Users\anitj\scoop\apps\oh-my-posh\17.12.0\themes\craver.omp.json" | Invoke-Expression

After saving, close and reopen the terminal to reload the profile. It'll make your PowerShell prompt like mine and everything will work together smoothly.

You can also change the prompt theme to match your preferences. For more information and customization options, you can refer to the oh-my-posh documentation at this link: 'https://ohmyposh.dev/docs/installation/customize'. It's a great resource for tailoring your PowerShell experience exactly the way you like it.

Sure, let's briefly discuss how to install two essential PowerShell modules: "Terminal Icons" and "PSReadLine."

Install Terminal Icons.

Terminal Icons is a module that adds icons to your terminal for a visually enhanced experience. You can install it by following these steps:

Open PowerShell.
Use the following command to install Terminal Icons:

Install-Module -Name Terminal-Icons -Scope CurrentUser

You may be prompted to install the module from the PSGallery repository. Confirm the installation.

Now, you have Terminal Icons installed, and it will automatically enhance your terminal interface with icons for files and folders, making it easier to navigate.

Now add this line to your profile

Import-Module -Name Terminal-Icons

Install PSReadLine

PSReadLine is a module that enhances the PowerShell command line editing experience. It adds features like syntax highlighting, tab completion, and more. To install it, follow these steps:

Open PowerShell.
Use the following command to install PSReadLine:

Install-Module -Name PSReadLine -Scope CurrentUser

Confirm the installation if prompted.

Once PSReadLine is installed, it will significantly improve your PowerShell command line editing capabilities. You can customize it further by modifying your PowerShell profile.

Now append this line to your profile

Import-Module -Name Terminal-Icons

These modules, Terminal Icons and PSReadLine, can enhance your PowerShell experience by providing a more visually appealing interface and improving your command line editing capabilities.

Now reload your poweshell by closing and reopening the terminal.

Custom Functions for Enhanced PowerShell Workflow

In PowerShell, you can tailor your experience by adding custom functions that simplify common tasks and streamline your workflow.
I use the below functions to make my life easier.

Git Functions

1. `gcom` - Simplify Git Commits

The gcom function streamlines the process of committing changes in a Git repository. It's perfect for those who frequently make Git commits. Here's how it works:

function gcom {
    git add .
    git commit -m "$args"
}

When you run gcom "Your commit message here", it automatically stages all changes and commits them with the provided message. No need to run separate git add and git commit commands.

2. `lazyg` - Commit and Push in One Step

For an even more streamlined Git workflow, the lazyg function takes the automation a step further. It stages changes, commits with your message, and then pushes the changes to the remote Git repository:

function lazyg {
    git add .
    git commit -m "$args"
    git push
}

Use it like this: lazyg "Your commit message here". This "lazy" approach automates multiple steps, making your Git interactions even more efficient.

Utility Functions

3. `which` - Locate Command Definitions

The which function is a handy utility for pinpointing the location of a specific command or function within your PowerShell environment. It takes a command name as an argument and returns its definition. For example:

function which($name) {
    Get-Command $name | Select-Object -ExpandProperty Definition
}

Running which Get-ChildItem will reveal the definition of the Get-ChildItem command in your environment.

4. `whichdir` - Find Command Directories

Similar to which, the whichdir function returns the directory path where a command or function is defined. It uses the Split-Path cmdlet to extract the directory path:

function whichdir($name) {
    $directory = Split-Path -Parent (Get-Command $name | Select-Object -ExpandProperty Definition)
    return $directory
}

Executing whichdir Get-ChildItem will provide the directory where Get-ChildItem is defined.

By adding these custom functions to your PowerShell profile, you ensure they are available each time you open PowerShell. They not only simplify Git-related tasks but also help you explore your PowerShell environment efficiently.

Git Stash : Beginner's Guide

Anit Jha — Fri, 07 Jul 2023 18:27:27 +0000

Introduction: The Power of Git Stash

Git stash is a powerful command that allows developers to temporarily save changes and switch branches without the need to commit unfinished work. It is recommended to use git stash sparingly, in rare situations. In this blog post, I will guide you through practical examples of using git stash in your everyday workflow, drawing from my own experience where git stash proved to be invaluable. These examples will help you effectively organize your work and seamlessly switch between branches. Let's get started!

Use Case 1: Stashing Changes Before Switching Branches

Imagine you are working on a new feature branch called "User-Profile" that involves modifying multiple files. Suddenly, you realize you need to make changes to the main branch to fix an urgent bug. Instead of committing the incomplete changes and polluting your commit history and dealing with merge conflicts later, you can use git stash to save your progress:

git stash

This command will stash your changes, allowing you to switch to the main branch and fix the urgent bug without conflicts. Once you have resolved the issue, you can return to the "User-Profile" branch and apply the stashed changes using:

git stash apply

Alternatively, you can use git stash pop. The git stash pop command removes the stash from the stash list, while git stash apply keeps the stash for future use.

Use Case 2: Stashing Multiple Sets of Changes

In some cases, you might be working on multiple tasks that require extensive modifications across various files. To keep things organized, you can stash each set of changes separately. For example:

git stash save "Task: Implement Payment Gateway"
git stash save "Feat: Introduce table view in dashboard"

By providing descriptive messages like "Task: Implement Payment Gateway," you can easily identify the stashed changes later. Once you have completed the first task, you can return to the second task and apply the stashed changes:

git stash apply stash^{/<stash-name>}

Use Case 3: Stashing Conflicting Changes

Imagine you are working on a project with a teammate, and you both make changes to the same file simultaneously. However, your teammate's changes conflict with yours.
This situation happened a few times, when I was working on the Moksha's website with my team-mate Harsh. In this situation, you can stash your changes to resolve the conflict:

git stash

After stashing your changes, you can pull the latest changes from the remote repository and apply them to your branch:

git pull origin main

Now that your branch is up to date, you can apply your stashed changes and resolve any conflicts that arise:

git stash apply

Use Case 4: Checking the Stash List

To keep track of your stashes, you can use the git stash list command. It provides an overview of your stashed changes:

git stash list

The output will display a list of stashes, including their respective stash index and descriptions. This allows you to easily identify and select the correct stash when applying or discarding changes.

Conclusion

Congratulations! You've learned how to leverage the power of git stash to effectively manage your work and switch between branches seamlessly. By stashing changes before switching branches, handling conflicting changes, and using descriptive messages, you can streamline your development workflow. Remember stash is not a very common command you will be using but it comes in handy in such situations.
Stay tuned for more valuable blogs about development and developer tools. Happy coding!