
## Table of Contents

1. [Introduction](#introduction)
2. [The Main Branch: Squash and Merge](#the-main-branch-squash-and-merge)
3. [Other Benefits](#other-benefits)
4. [Other Cases for Main](#other-cases-for-main)
5. [Example: Create Feature Branch](#example-create-feature-branch)
6. [The Release Branch: Fast-Forward](#the-release-branch-fast-forward)
7. [Syntax: Syncing Main to Release](#syntax-syncing-main-to-release)
8. [Conclusion](#conclusion)

## Introduction

This blog demonstrates a clean and efficient Git workflow tailored for small teams. We will focus on keeping the `main` branch history readable while ensuring the `release` branch remains a stable mirror of production.

## The Main Branch: Squash and Merge

When working on features or bugs, developers often create dozens of "work-in-progress" commits. To keep the `main` branch clean, we use the **Squash and Merge** pattern. This collapses all commits from a branch into a single, high-quality commit on `main`.

- **Feature Branches (`feature/description`):** Use this for new development.
- **Bug Branches (`bugs/description`):** Use this for fixing issues found in development.

## Other Benefits

- **Feature Reversion:** If a feature introduced a failure, squashing makes it easier to revert the change.
- **Simplified "Git Blame":** `git blame` will point to a feature instead of an individual commit like `fixed typo`.
- **Avoiding "Broken" Intermediate Commits:** Sometimes in a feature branch a developer fixes the build or unit tests. If you don't use squash and keep all history, the main branch will contain "broken" build commits.

## Other Cases for Main

Beyond features and bugs, you might merge into `main` for:

- **Refactoring:** Code cleanup that doesn't change functionality.
- **Documentation:** Updates to README files or API docs.
- **CI/CD Updates:** Modifying GitHub Actions or deployment scripts.
- **Dependency Updates:** Merging automated PRs (like Dependabot) to keep libraries secure.

## Example: Create Feature Branch

```
# Ensure you are on main and up to date
git checkout main
git pull origin main

# Create and switch to a new feature branch
git checkout -b feature/describe-feature
```

## The Release Branch: Fast-Forward

For small teams, we want the `release` branch to be easy to manage. We use the **Fast-Forward** pattern, which keeps all commit history identical between `main` and `release`.

**Alternative Approaches:**

- **Merge Commits:** Some teams use `--no-ff` to create a dedicated "Merge node" to show exactly when a release happened.
- **Squash to Release:** Some teams squash all of `main` into one single "Version 1.0" commit on the release branch, though this makes tracking individual changes harder.

## Syntax: Syncing Main to Release

To move your verified code from `main` to `release` using the fast-forward pattern, run:

```bash
git checkout release
git merge main --ff-only
git push origin release
```

## Conclusion

By using Squash for development and Fast-Forward for releases, your team maintains a professional, readable history that is easy to debug. Hopefully, you find this pattern helpful for your team's workflow!


A practical guide on using Squash and Fast-Forward patterns to manage a clean Git workflow.

Git Merge Patterns for Main and Release Branches


## Table of Contents

- [Introduction](#introduction)
- [Filter by Author](#filter-by-author)
- [Filter by Date](#filter-by-date)
- [Filter by Author and Date](#filter-by-author-and-date)
- [Pretty Print Commit Log](#pretty-print-commit-log)
- [Navigation Commands](#navigation-commands)
- [Conclusion](#conclusion)

## Introduction

Here are a few useful commands if you want to get a list of git commit
information. These commands help you filter, format, and navigate through your
git log history.

## Filter by Author

This will list all the commits by the contributor.

```
git log --author="Contributor's name"
```

## Filter by Date

Get commits from **19 April 2020**.

```
git shortlog -s -n --since="19 April 2020"
```

## Filter by Author and Date

Get commits for the contributor since 19 April 2020.

```
git log --author="Your contributor" --oneline --since="19 April 2020"
```

## Pretty Print Commit Log

Same commit log but make it pretty print.

```
git log --pretty="%C(Yellow)%h  %C(reset)%ad (%C(Green)%cr%C(reset))%x09 %C(Cyan)%an: %C(reset)%s" --author="contributor" --since="19 May 2020 12:00:00 AM"
```

## Navigation Commands

Quit the command line by **:q**.

```
:q
```

Use **:h** for the help command.

```
:h
```

## Conclusion

These are a few handy git log commands that can help you quickly filter commits
by author, date, or both, and format the output for easier reading. Combine
these options to find exactly the commit information you need.


Here are a few useful commands if you want to get a list of git commit information.

Few Useful Command for Git Log Commit


## Table of Contents

1. [Introduction](#introduction)
2. [Squash Commits with Soft Reset](#squash-commits-with-soft-reset)
3. [Conclusion](#conclusion)

## Introduction

A quick note to show how to squash all git local commits into one.

A scenario would be that you've been checking in lots of commits to your own
local branch, and when you're ready to push them to the origin branch, you don't want
to check in so many commits. For example, depending on the developer, you might have
100 commits.

Here is a quick note for doing that in the command line.

## Squash Commits with Soft Reset

First, make sure you are on the correct branch.

```
git checkout YourBranch
```

Then, use the **soft reset** to the origin branch.

```
git reset --soft origin/YourBranch
```

Now, at this moment, all your commits should become one. You just need to
commit that change.

If you use Visual Studio 2019, it already has a feature that lets you squash
all local commits into one. However, if you still use Visual Studio 2015, you
will have to do it in the command line.

## Conclusion

Using `git reset --soft` is a simple and effective way to squash all local commits into a single commit before pushing to the remote branch.


A quick note to show how to squash all git local commits into one.

How to Squash All Git Commits into One


## Table of Contents

1. [Introduction](#introduction)
2. [Common Issue with Git in Visual Studio](#common-issue-with-git-in-visual-studio)
3. [Conclusion](#conclusion)

## Introduction

This post covers a common issue encountered when using Git within Visual Studio and provides steps to resolve it.

## Common Issue with Git in Visual Studio

### Merge or Commit Error

If you're using Visual Studio's Git merge to merge code from a source branch to a target branch and there are new commits on the target branch, you might see the following error:

```
An error occurred. Detailed message: 2 uncommitted changes would be overwritten by merge
```

You'll probably still see this error after trying to pull from the target branch a couple of times. I think this might be a bug when using Visual Studio's Git integration, but some people say it might be caused by a locked file. Either way, it is something that should work, but Git in Visual Studio is not handling it correctly. The following are fixes I have tried that work so far:

1. After checking out the target branch, always pull first, then perform other operations like merge or push.

2. Although #1 should work most of the time, if you forgot to pull or even after you pull someone else pushes their changes, you might still see the above error.

3. **Restart Visual Studio** — this might work.

4. Open the command line from your current source folder and type the following:

```
git status
git pull
```

## Conclusion

When encountering merge or commit errors in Visual Studio's Git integration, the most reliable fix is to always pull before performing other operations. If the issue persists, try restarting Visual Studio or using the command line directly.


Common issues and fixes when using Git with Visual Studio.

Git with Visual Studio


## Table of Contents

1. [Introduction](#introduction)
2. [Import Repositories from TFVC to Git](#import-repositories-from-tfvc-to-git)
3. [Conclusion](#conclusion)

## Introduction

Git, TFVC, and SVN are just a few of the many source control systems that exist today. Others include Helix VCS, Mercurial, Rational ClearCase, CVS, Kiln, Bazaar, Fossil, Monotone, Plastic SCM, AWS CodeCommit, and more. Some of them will eventually disappear...

![Image result for disappear funny image](http://martinliebermandotcom.files.wordpress.com/2012/08/disappear-cliff.jpg)

I only list **Git**, **TFVC**, and **SVN** because I've been using these for a while, and they're all popular.

## Import Repositories from TFVC to Git

Based on what I have seen so far, I think it's better to just use Git instead.

## Conclusion

When migrating source code between version control systems, Git is generally the recommended choice due to its widespread adoption and robust tooling. Consider importing your existing repositories from TFVC or SVN to Git for a more modern workflow.


A guide on migrating source code between version control systems such as Git, TFVC, and SVN.

Migrate Source Code


#### Table of Contents

1. How to Use git to commit to GitHub
2. Git local commit
3. Commit to GitHub
4. Clone Git from Github
5. Clone Git origin url A then Check-in to Git origin url B
6. List of Other Command
7. List of Git command

## How to Use git to commit to GitHub

Following example is for windows enviroment and command is use windows'
Command Prompt.

First you need to setup the git's user and email, check the current user and
email by run following command.

```
> git config --list
```

If the `user.name` or `user.email`is not there, try run
following command to set username and email address.

```
> git config --global user.name "test"
> git config --global user.email "test.email"
```

Now, you're ready for git check-in locally, if you type
`git commit -m "test commit"` for commit. Type
`git log`, you'll see the log history of the git commit.

Init Git

Run this command to initialize the git.

```
> git init
```

### Git local commit

```
> git add .
```

```
> git commit -m "Initialize repository"
```

### Commit to GitHub

```
> git remote add origin {your github address}
> git push -u origin master

```

### Clone Git from Github

```
> git clone {your github address}


```

### Clone Git origin url A then Check-in to Git origin url B

```
> git clone {url A}
> delete git folder
> git remote set-url origin {url B}
> git pull {url B}
> git push -u origin master


```

In case of `Git push` doesn't work, and you tried possible solution
already, then you could also try `git push --force`, to force
update to the remote location.

### List of Other Command

```
> rmdir {folder name} /s
```

### List of Git command

  - `git config --list`

  - `git config --get remote.origin.url`

    - check current git repository's remote url

`git config --global user.name "{your name}"`
`git config --global user.email "{your email}"`
`git init` - use git for current folder
`git commit "commit message"`

`git commit -m "commit comment, message must in one line"`

`git commit --amend -m "commit message"` - append previous commit

`git remote add origin "{Github address}"`
`git push -u origin master`
`git log`
`git log --oneline` pretty view for the log
`git status`
`git checkout --{file name}`
`git diff` want to know where is the change
`git diff --cached` show what files had changed by commit
`git reset HEAD` cancel the `git add`
`git config -l`show all the git config settings
`git help config`show config help page
git merge --abort

    - undo merge


Few Commands About Use Git to Commit to GitHub


After installed following tools, you should be able to use git with visual
studio 2012.

1. Install Visual Studio 2012 update 4

2. Install Visual Studio Git Tool

3. restart visual studio

Open Team Exploer, then you'll see Git selection.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_08g77sh2o.png)


This is a memo about how to use Git with Visual Studio 2012.