DEV Community: Selva

Mastering Advanced Git Commands: A Practical Guide

Selva — Mon, 28 Apr 2025 15:40:43 +0000

If you’ve been using Git for a while, you probably know the basics — clone, commit, push, pull.
But Git is a powerful tool, and there's a whole world beyond the basics that can make your workflow faster, cleaner, and smarter.

In this blog, we'll dive into advanced Git commands that every developer should know!

git stash — Save Work Without Committing Ever got stuck when you need to switch branches but don’t want to commit half-done work?

git stash

It saves your changes in a "stash" and cleans your working directory.

Later, you can reapply the stashed changes with:

git stash pop

Tip: You can even stash with a message:

git stash save "WIP: fixing login bug"

2.git cherry-pick — Apply Specific Commits
Want to pick a single commit from one branch and apply it to another?

git cherry-pick <commit-hash>

Great for moving small bug fixes without merging entire branches.

3.git rebase— Rewrite History Cleanly
Instead of a messy merge, you can reapply commits on top of another branch:

git checkout feature-branch git rebase main

Makes history linear and clean.

Interactive rebasing (git rebase -i) even lets you squash commits together!

git rebase -i HEAD~5

You can pick, squash, or reword commits easily during interactive rebase.

4.git reflog — Find Lost Commits
Deleted a branch or a commit accidentally? Don’t worry!

git reflog

It shows a log of everything you've done, including commits that aren't reachable anymore.

You can recover with:

git checkout <commit-hash>

5.git reset — Undo Changes
Soft reset (keep changes but unstage):

git reset --soft HEAD~1

Mixed reset (unstage and keep working directory):

git reset --mixed HEAD~1

Hard reset (dangerous! discard changes):

git reset --hard HEAD~1

Use hard resets carefully — once changes are gone, they're usually gone for good unless you use reflog.

6.git bisect — Find Bugs Faster
Git can automatically help you find the commit where a bug was introduced!

Start bisecting:

git bisect start

Mark the current version as bad:

git bisect bad

Mark an older working version as good:

git bisect good <commit-hash>

Git will checkout commits one by one — you test and tell Git whether it's "good" or "bad" until it narrows down the exact problematic commit.

7.git tag — Mark Important Points
Use tags for releases, versions, or milestones.

Create a lightweight tag:

git tag v1.0

Create an annotated tag:

git tag -a v1.0 -m "Release version 1.0"

Push tags:

git push origin v1.0

Or push all tags:

git push origin --tags

8.git clean — Remove Untracked Files
Want to remove junk (files not tracked by Git)?

Preview what would be deleted:

git clean -n

Actually delete them:

git clean -f

Be very careful with git clean — it’s powerful!

9.git remote prune — Clean Up Deleted Branches
Sometimes remote branches get deleted, but you still see them locally. Clean them up with:

git remote prune origin

10.git shortlog — Summarize Contributions
Want to generate a quick summary of who contributed?

git shortlog -sn

You'll get a list of contributors sorted by the number of commits!

Final Thoughts

Learning these advanced Git commands will:

Save you time

Help you recover faster

Keep your repositories cleaner

Impress your team!

If you're serious about becoming a Git pro, practice these commands on a test repository first.
Over time, they’ll become second nature.

If you found this helpful, don't forget to ❤️ the post and follow for more tips!
Feel free to comment your favorite Git tricks below!

DockerFile Image Creation and Pushing to DockerHub

Selva — Fri, 25 Apr 2025 17:37:51 +0000

Whether you're a developer automating deployments or a student getting started with DevOps, learning how to create Docker images and push them to DockerHub is essential. In this post, we’ll walk through:

Writing a simple Dockerfile
Building a Docker image
Tagging the image
Pushing it to DockerHub

Let’s get started!

What is a Dockerfile?

A Dockerfile is a plain text file that contains instructions on how to build a Docker image. Think of it as a recipe — it tells Docker how to build an environment tailored for your application.

Dockerfile


FROM python:3.14.0a7-alpine3.21

# Install required system dependencies
RUN apk add --no-cache build-base musl-dev linux-headers

# Install Python libraries
RUN pip install --upgrade pip && \
    pip install pandas scikit-learn matplotlib

# Copy and run your script
COPY . .
CMD [ "python", "hello_world_ml.py" ]

1. Build the Docker Image

docker build -t DockerUserName/dockerfilename:latest .

2. Run the Docker Image

docker run --rm DockerUserName/dockerfilename:latest

3. List Docker Images

docker image ls

4. Push the Image to DockerHub

docker push DockerUserName/dockerfilename:latest

GITHUB commands

Selva — Wed, 23 Apr 2025 16:49:57 +0000

Step-by-Step Git Commands Execution:

Initialize a Git repository:
git init
Creates a new Git repository in the folder 24MCR095.

Add a file to staging area:
git add 24MCR095.txt
Adds 24MCR095.txt to the staging area.

Commit the file:
git commit -m "Added Personal Details"
Creates a commit with the message "Added Personal Details".

Check Git status:
git status
Shows that 24MCR095.txt has been modified but not staged.

View commit log:
git log
Displays the commit history (one commit at this point).

Add remote GitHub repository:
git remote add origin https://github.com/selva192003/24MCR095.git
Links the local repository to a remote GitHub repo.

Check current branch:
git branch
Shows the current branch is master.

Rename branch from master to main:
git branch -M main
Renames the current branch to main.

Set Git global config for email and username:
git config --global user.email "dhoniselva192003@gmail.com" git config --global user.name "selva192003"
Sets your global Git identity.

Push code to remote repo for the first time:
git push -u origin main
Pushes the main branch to GitHub and sets upstream tracking.

Sample Screenshots:

Then , Again We will Modify or add new file means we need to follow the same steps, like

git add .
git commit -m “message”
git push origin main

Git Commands used in this session:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git init
git clone <repo_url>
git status
git add <file>
git add .
git commit -m "Your message"
git branch
git branch <branch_name>
git checkout <branch_name>
git checkout -b <branch_name>
git pull origin <branch_name>
git push origin <branch_name>
git merge <branch_name>
git rebase <branch_name>
git restore <file>
git reset --soft HEAD~1
git reset --hard HEAD~1