DEV Community: Abinash Behera

From Git Beginner to Advanced: The Complete Guide Every Developer Should Know

Abinash Behera — Thu, 25 Jun 2026 10:37:05 +0000

A practical guide to mastering Git—from your first commit to advanced collaboration and repository management.

Introduction

Whether you're building personal projects, contributing to open source, or working in a professional software team, Git is one of the most important tools you'll use every day.

Unfortunately, many developers only know a handful of commands like git add, git commit, and git push, while Git offers far more powerful features that simplify collaboration, debugging, and version management.

In this guide, we'll take a step-by-step journey from Git basics to advanced workflows, covering the commands and concepts every developer should know.

Let's get started.

1. What is Git?

Git is a distributed version control system that tracks changes in your source code.

It allows you to:

Track every code change
Collaborate with teams
Restore previous versions
Experiment safely using branches

2. Installing Git

Download Git:

https://git-scm.com/

Verify installation:

git --version

3. Configure Git

Before using Git, configure your identity.

git config --global user.name "Your Name"

git config --global user.email "you@example.com"

Check your configuration:

git config --list

4. Create Your First Repository

Initialize Git inside a project.

git init

Check repository status.

git status

5. Tracking Files

Stage files:

git add .

git add filename.cs

Commit your changes.

git commit -m "Initial commit"

6. Understanding the Git Workflow

Git has three main areas:

Working Directory

↓

Staging Area

↓

Repository

Understanding this workflow helps avoid many beginner mistakes.

7. Viewing Commit History

git log

Compact version:

git log --oneline

Beautiful graph:

git log --graph --all --decorate

8. Branching

Create a branch.

git branch feature-login

Switch branches.

git switch feature-login

git checkout feature-login

9. Merging Branches

Merge your feature into main.

git checkout main

git merge feature-login

10. Working with GitHub

Connect your repository.

git remote add origin https://github.com/user/project.git

Push code.

git push -u origin main

Clone a repository.

git clone https://github.com/user/project.git

11. Pulling Latest Changes

git pull origin main

Fetch only:

git fetch

Difference:

fetch downloads changes
pull downloads and merges

12. Undo Mistakes

Unstage files.

git restore --staged file.cs

Discard changes.

git restore file.cs

Undo last commit.

git reset --soft HEAD~1

13. Git Stash

Temporarily save unfinished work.

git stash

Restore it.

git stash pop

List stashes.

git stash list

14. Resolving Merge Conflicts

Conflicts happen when two branches modify the same code.

Steps:

Open conflicted file
Resolve differences
Save file
Stage changes
Commit merge

15. Cherry Pick

Copy one commit from another branch.

git cherry-pick commit_hash

Perfect for bug fixes.

16. Interactive Rebase

Clean commit history.

git rebase -i HEAD~5

Useful for:

Squashing commits
Renaming commits
Reordering history

17. Git Tags

Create release versions.

git tag v1.0.0

Push tags.

git push origin --tags

18. Git Ignore

Ignore unnecessary files.

Example:

bin/
obj/

.vs/

node_modules/

.env

19. Useful Git Aliases

git config --global alias.st status

git config --global alias.co checkout

git config --global alias.br branch

git config --global alias.cm commit

Now simply run:

git st

git co

git br

20. Advanced Git Features

Explore these powerful capabilities:

Rebase
Bisect
Worktrees
Reflog
Hooks
Submodules
Sparse Checkout
Git LFS
Signed Commits
GitHub Actions Integration

Common Git Commands Cheat Sheet

git init
git clone
git status
git add .
git commit -m ""
git push
git pull
git fetch
git branch
git switch
git checkout
git merge
git rebase
git stash
git reset
git restore
git revert
git tag
git cherry-pick
git log --oneline

Best Practices

✅ Commit frequently

✅ Write meaningful commit messages

✅ Keep branches focused

✅ Pull before pushing

✅ Never commit secrets

✅ Use .gitignore properly

✅ Review changes before committing

Final Thoughts

Git is much more than a tool for saving code—it's the foundation of modern software development. Mastering Git means writing code with confidence, collaborating effectively, and recovering from mistakes when they happen.

Don't try to learn everything at once. Start with the basics, practice daily, and gradually explore advanced features like branching, rebasing, cherry-picking, and Git hooks. Over time, these skills will become second nature and significantly improve your development workflow.

Happy coding! 🚀

If you found this guide helpful, let me know which Git command you use the most—or which advanced feature you're excited to learn next!

10 Hidden Features Every .NET Developer Should Know

Abinash Behera — Thu, 25 Jun 2026 10:34:32 +0000

A practical guide to writing cleaner, safer, and more modern C# code.

Introduction

The .NET ecosystem evolves rapidly, and with every release Microsoft introduces features that make development easier, cleaner, and more efficient. Unfortunately, many developers continue writing code the same way they did years ago, missing out on improvements that can simplify their daily work.

In this article, we'll explore 10 hidden (or underused) .NET features that every developer should know. These aren't gimmicks—they're practical tools you can start using today in real-world applications.

Whether you're building ASP.NET Core APIs, desktop applications, or cloud services, these features will help you write better code.

1. Collection Expressions

One of the cleanest additions to modern C# is Collection Expressions.

Instead of writing:

int[] numbers = new int[] { 1, 2, 3, 4, 5 };

You can now simply write:

int[] numbers = [1, 2, 3, 4, 5];

It also works with lists:

List<string> names =
[
    "John",
    "Emma",
    "David"
];

Why it matters

Less typing
Cleaner syntax
Easier to read
Perfect for initialization

2. Primary Constructors

Dependency Injection becomes much cleaner.

Old style:

public class UserService
{
    private readonly IUserRepository _repository;

    public UserService(IUserRepository repository)
    {
        _repository = repository;
    }
}

Modern C#:

public class UserService(IUserRepository repository)
{
}

Benefits

Removes boilerplate
Cleaner classes
Easier maintenance

3. Required Members

Forget assigning required properties? The compiler now helps you.

public class Employee
{
    public required string Name { get; set; }

    public required string Email { get; set; }
}

Now this won't compile:

var employee = new Employee();

Correct:

var employee = new Employee
{
    Name = "Abinash",
    Email = "abinash@example.com"
};

Benefits

Compile-time safety
Prevents null issues
Better models

4. TimeProvider

Instead of using:

DateTime.Now

Use:

TimeProvider.System.GetLocalNow();

Why?

Because DateTime.Now cannot easily be mocked during testing.

TimeProvider can.

Perfect for:

Unit Tests
Scheduling
Background Services

5. Keyed Dependency Injection

Need multiple implementations?

Example:

builder.Services.AddKeyedScoped<IPaymentService, PaypalService>("paypal");

builder.Services.AddKeyedScoped<IPaymentService, StripeService>("stripe");

Inject the one you need.

No more huge switch statements.

6. Rate Limiting Middleware

Protect your API from abuse.

Enable:

builder.Services.AddRateLimiter();

app.UseRateLimiter();

Example:

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("api", limiterOptions =>
    {
        limiterOptions.PermitLimit = 10;
        limiterOptions.Window = TimeSpan.FromMinutes(1);
    });
});

Benefits:

Stops spam
Prevents brute-force attacks
Protects servers

7. File-Scoped Namespaces

Old style:

namespace MyProject
{
    public class User
    {

    }
}

Modern:

namespace MyProject;

public class User
{

}

Cleaner.

Less indentation.

Much easier to navigate.

8. Global Using Directives

Instead of repeating:

using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

In every file...

Create:

GlobalUsings.cs

global using Microsoft.EntityFrameworkCore;
global using Microsoft.AspNetCore.Mvc;
global using System.Text.Json;

Now every file automatically has access.

9. Pattern Matching

Old:

if (person is Employee)
{
}
else if(person is Student)
{
}

Modern:

return person switch
{
    Employee e => e.Name,
    Student s => s.Name,
    _ => "Unknown"
};

Much cleaner.

Much more readable.

10. Minimal APIs

Creating APIs has never been easier.

var app = builder.Build();

app.MapGet("/users", () =>
{
    return Results.Ok(users);
});

app.Run();

Perfect for:

Microservices
Internal APIs
Prototypes
Serverless applications

Bonus Features Worth Exploring

Span
Memory
FrozenDictionary
Source Generators
Native AOT
Generic Math
Interceptors
UTF-8 String Literals
CallerArgumentExpression
ConfigureAwaitOptions

Final Thoughts

The .NET platform keeps getting better with every release, but many of its best improvements go unnoticed because developers stick to familiar patterns.

By adopting features like Collection Expressions, Primary Constructors, Required Members, TimeProvider, and Minimal APIs, you can write code that's cleaner, safer, and easier to maintain.

The best part? You don't need to learn an entirely new framework—just start incorporating these features into your existing projects one at a time.

Small improvements compound over time, and modern C# gives you the tools to build applications that are both elegant and productive.

Happy coding! 🚀

If you enjoyed this article, let me know which hidden .NET feature you use the most—or which one you plan to try next!

Why Every Developer Should Learn Git Before Learning Another Programming Language

Abinash Behera — Wed, 24 Jun 2026 15:58:27 +0000

When I started coding, I believed learning more languages would make me a better developer.

I was wrong.

The skill that improved my workflow the most wasn't a new framework, library, or language—it was Git.

The Reality of Software Development

Writing code is only one part of being a developer.

Real-world development involves:

Managing code changes
Working with teammates
Tracking project history
Recovering from mistakes
Experimenting with new ideas safely

Without version control, even a small mistake can become frustrating and time-consuming.

Why Git Is So Important

Git acts as a safety net for developers.

It allows you to:

Track every change in your project
Create separate branches for new features
Revert mistakes quickly
Collaborate efficiently with other developers
Maintain a complete history of your work

Commands Every Beginner Should Know

git init

git add .

git commit -m "Initial Commit"

git branch

git checkout

git merge

git pull

git push

You don't need to master every Git command immediately. Start with the basics and build confidence over time.

Final Thoughts

Before learning another programming language, spend some time learning Git properly.

It may not seem exciting at first, but it is one of the most valuable tools in a developer's toolkit.

Learning Git won't just save your code. It will save your time.

Happy Coding! 🚀

git #github #programming #webdev

Why We Fall Harder for People Who Avoid Us

Abinash Behera — Wed, 24 Jun 2026 15:48:37 +0000

Have you ever noticed that the people who give us the least attention sometimes occupy the most space in our minds?
It feels like love, but often it's something deeper: the desire to be seen.
When someone avoids us, ignores our messages, or seems emotionally unavailable, our mind starts searching for answers. We begin wondering what we did wrong, what we can change, and how we can finally earn their attention. The less recognition we receive, the more valuable it starts to feel.
Psychology calls this intermittent reinforcement. When attention comes rarely or unpredictably, our brains can become even more attached to receiving it. A single reply, a brief smile, or a moment of warmth can feel incredibly rewarding because it is so scarce.
But beneath that attraction is often a simple human need:
"I want to be acknowledged."
We don't just want the person. We want the feeling that we matter to them.
Sometimes the obsession is not about love at all. It's about proving to ourselves that we are worthy of being chosen, noticed, and valued.
The difficult truth is that recognition earned through constant chasing rarely brings lasting peace. Real connection grows where attention is given freely, not where it must be endlessly pursued.
The healthiest relationships are not the ones that leave us questioning our worth.
They are the ones that quietly remind us of it.
"The strongest attraction is not always toward the person who loves us the most, but toward the person whose recognition we believe we still need to earn."

share your opinion

Abinash Behera — Thu, 18 Jun 2026 05:37:43 +0000

Abinash Behera

Jun 18

🚀 Building a Complete Driver Management System with ASP.NET Core MVC, Web API & SQL Server

#showdev #dotnet #sql #webdev

1 min read

🚀 Building a Complete Driver Management System with ASP.NET Core MVC, Web API & SQL Server

Abinash Behera — Thu, 18 Jun 2026 05:36:27 +0000

Recently, I worked on a Driver Management System where I implemented multiple modules using ASP.NET Core MVC, Web API, Entity Framework Core, and SQL Server.

Features Implemented

✅ Driver Management CRUD Operations

✅ Driver Allowances Management

✅ Driver Advances Management

✅ Driver Deductions Management

✅ Driver Expenses Management

✅ Bulk Status Update Functionality

✅ DataTables Integration

✅ Search, Filter & Export Features

✅ API and MVC Layer Integration

✅ Validation and Error Handling

Technologies Used

ASP.NET Core MVC
ASP.NET Core Web API
Entity Framework Core
SQL Server
Bootstrap
jQuery
DataTables

** Challenges Faced**

One of the major challenges was handling computed SQL columns and maintaining consistency between API and MVC layers.

I also optimized DataTable performance and improved user experience by implementing dynamic filtering and responsive tables.

** Key Learnings**

Better understanding of REST API design
Entity Framework Core mappings
SQL Server optimization
MVC and API integration patterns
Clean CRUD architecture

** Final Thoughts**

Working on real-world enterprise modules helps developers gain practical experience beyond tutorials.

Every completed module teaches something new about scalability, maintainability, and problem-solving.

Happy Coding! 🚀