DEV Community: jana009

Stop Stashing! Use Git Worktree to Handle Hotfixes Parallelly

jana009 — Sat, 18 Jul 2026 17:46:05 +0000

Today I learned about a game-changer for my Git workflow: Git Worktree.

If you've ever been in the middle of a complex feature and suddenly had to drop everything to fix a critical bug on another branch, you probably reached for git stash. While stashing works, it can be a hassle to manage multiple stashes and keep track of where you left off.

Here is how git worktree allows you to work on multiple branches simultaneously without touching git stash.

The Problem with the "Stash" Workflow

Usually, when a hotfix comes in, we do this:

git stash (Save current changes)
git checkout main
git checkout -b hotfix-branch
Fix the bug, commit, and push.
git checkout original-branch
git stash pop (Try to remember what we were doing)

This context switching is slow and can lead to merge conflicts or lost work if you have a messy stash history.

The Solution: Git Worktree

Instead of switching branches in your current directory, git worktree lets you create a separate directory for a specific branch. This allows you to open both branches in different windows of your IDE and work on them at the exact same time.

1. Adding a Worktree

To create a new folder in your parent directory for a hotfix, run:

git worktree add ../hotfix-bug -b hotfix-bug main

What this does:

Creates a new folder named hotfix-bug one level up from your current folder.
Creates a new branch called hotfix-bug based on main.
Checks out that branch into that new folder.

Now you can simply open a new VS Code window (or your preferred editor) in that ../hotfix-bug folder and fix the bug while your main project remains exactly as you left it.

2. Committing and Pushing
In the new folder, you can follow your usual flow:

git add .
git commit -m "Fixed the critical bug"
git push origin hotfix-bug

Cleaning Up Once the bug fix is merged and you no longer need the parallel folder, it’s important to keep your worktree clean. Move back to your main project directory and run:

cd ../main
git worktree remove ../hotfix-bug

This deletes the temporary folder and unregisters it from Git, leaving your environment tidy.

Conclusion

git worktree is perfect for those "drop everything and fix this" moments. It keeps your main workspace clean and prevents the "stash-and-dash" headaches.

References

What are git worktrees, and why should I use them? - The GitHub Blog

Git worktrees have been around since 2015, but it wasn't until recently they became popular. Learn what they are, how to use them, and why you might.

github.blog
git-scm.com

</a> </div> </div>

Exception Handling

jana009 — Sat, 23 Sep 2023 20:45:35 +0000

Hi Guys,

In programming, lots of time we face errors. As a programmer we need to know how to handle those unexpected scenario in a best way so that's why we are going to see about Exception Handling

Exception:

Exception is an unwanted or unexpected situation which causes the program to terminate abnormally.

Default Exception Handler:

When executing the program if an exception occurs then the method in which the exception created is responsible to create the Exception Object.The Exception Object Contains 3 information

Name of the Exception
Description of the Exception
Stack trace(provide the information from which method and which line exactly the error occurs) and handover this object to the JVM(Java Virtual Machine).

Then JVM gives the object to Default Exception Handler and terminates the program abnormally without executing rest of the lines.

Example with no Exception:

public class ExcepExample{
    public static void main(String args[]){

        int num=10/2;
        System.out.println("Print the A Value  "+num);
        System.out.println("End of the Program! ");

    }
}

Output

Example with Exception

public class ExcepExample{
    public static void main(String args[]){

        int num=10/0;
        System.out.println("Print the A Value  "+num);
        System.out.println("End of the Program! ");

    }
}

Output

In Example Without Exception the program runs successfully and we got the output but in the Example with Exception the program terminates abruptly without executing the rest of the lines and prints the details of the Exception ArithmeticException.
In above exception exception example
ArithmeticException => Name of the Exception
/ by zero => Description of the Exception
at ExcepExample.main(ExcepExample.java:4) => Is the stack trace.

So as programmer we need to handle this scenario and make program to terminate in normal way.

For that will use try...catch

Try...Catch

Syntax

try{ //code Which cause the Exception }Catch(Exception ex){ // Customize the how to display the exception }

Example

public class ExcepExample{
    public static void main(String args[]){

        try{
                int num=10/0;
                System.out.println("Print the A Value  "+num);
        }catch(ArithmeticException ex){
            ex.printStackTrace();
       }

        System.out.println("End of the Program! ");

    }
}

Output

Callback Function

jana009 — Fri, 29 Jul 2022 19:06:54 +0000

Hi guys,

Today we are going to discuss the Callback function.

Callback is the one of the weird concept if you people are coming from the C programming language.

Callback is nothing but a function which is passed as an parameter to the other function and being used inside that(the function where it is passed as an parameter.) function

Example

function greeting(name) {
alert('Hello ' + name);
}

function processUserInput(callback) {
var name = prompt('Please enter your name.');
callback(name);
}

processUserInput(greeting);

Example Source

Snippet Explanation :

First the proceessUserInput method executes which takes greeting function as an parameter, Where the first line of the method asks as to type the name.
Second line where the greeting(callback) function calls which the function inside the other function.
It takes name output from the processUserInput and alerts the greeting message.

OUTPUT

Please enter your name. John

Hello John

That's it 😃

Thanks! for reading

Comment your feedback to boost up 💪 my writing

Javascript

jana009 — Sat, 25 Jun 2022 19:32:13 +0000

Hello👋

It's my first blog so i am not familiar with writing the blog...So could you provide me tips and feedbacks that needs to improved in the comment section .Thanks in advance!!!

Javascript is a scripting language which was used for manipulating dom but now it becomes more powerful with different frameworks.

Javascript Data types:

Primitive Types

In Primitive types the datas are stored as values in memory(Call by value) and are fixed in size
```
  - Boolean
  - Null
  - Undefined
  - Number
  - String
  - Symbol
```
Non-Primitive Type

In Non-Primitive types the datas are stored in memory with its address and reference the value(Call by reference).It is not in fixed size
```
  -Objects
```

Boolean
It is either true or false
Example: var isOdd =true;

Null
In javascript null is an type where it as absence of any type.(i.e no memory was created for that particular value)
Example: var name=null;

Undefined
It means the variable with out any value.
Example:var name;

Number
In javascript both integer and floating values are assigned with 'Number' type
Example:var value1=5;/var value2=5.2

String
It is a combination of characters
Example:var greeting="hello";

Objects
In javascript objects are key and value pair
Example:var name={firstName:"john",
lastName:"doe"
}

DEV Community: jana009

Stop Stashing! Use Git Worktree to Handle Hotfixes Parallelly

What are git worktrees, and why should I use them? - The GitHub Blog

Exception Handling

Exception:

Default Exception Handler:

Example with no Exception:

Example with Exception

Try...Catch

Syntax

Example

Callback Function

Javascript

Javascript Data types: