Gain insights into Git version control, delving into commits, branches, and remote collaboration. Learn about resolving conflicts and handling erroneous changes to manage software projects efficiently.

MBE-  Beginning Git Version Control by Thomas Makzan.png

DockerGit.tar.gz

email

name

Grouping 

Git is one of the most widely used version control tools in the software industry. Whether working on frontend or backend, native or server-side applications, every software developer should be comfortable with Git version control.

In this course, you’ll learn how Git is used in software projects and the basics of version control. Moreover, you’ll learn commits, pushing code, branches, and Git Stash. Finally, you’ll learn to use Git for remote collaboration, including reconciling conflicts and correcting erroneous changes with fetch, pull, reversion, and cherry-picking. At each step, you’ll solve quizzes to test your knowledge.

By the end of this course, you’ll have a working knowledge of Git and its use in version control. You’ll be able to proficiently and efficiently manage your future software projects.

Getting Started with Git Version Control

# Working `development` branch
The `development` branch is the latest compilable code. It’s like a nightly build.

When the `development` branch is tested stable, we can then fast-forward the `production` branch into it.

## Use `git merge` with `--no-ff`

When we merge and fast-forward the stable `production` branch into a `development` branch, we may choose to merge with the option `--no-ff`. The `no-ff` option stands for “no fast-forward.”

This means that even the stable branch can be fast-forwarded. We still want to create a new commit object. In such a case, when we `git log` the graph, we can always see that it’s merged with two parent nodes.

This practice allows us to log when and where the main `production` branch has moved. For example, given the following commit log, the `development` branch is ready for production. 
``` Shell
* 60c1acd (HEAD -> development) Complete feature B and tested.
* 4a4571e Kick start feature B.
* 8006e3e (production) Merge feature A.
* 31666e2 Complete feature A.
* b0d3c42 Init the example project.
```
If we switch to the `production` branch and merge the `development` branch, we lose where the `production` branch was.

``` Shell
 $ git switch production
 $ git merge development
```
The `git log` becomes the following, and we lose which commit `production` was pointing to before the merge.

``` Shell
* 60c1acd (HEAD -> production, development) Complete feature B and
tested.
* 4a4571e Kick start feature B.
* 8006e3e Merge feature A.
* 31666e2 Complete feature A.
* b0d3c42 Init the example project.
```
Instead, if we use `-no-ff` as follows, we create a new branch that merges the `development` branch.
``` Shell
 $ git switch production
 $ git merge --no-ff development
```
Now, we see the following commit log:

``` Shell
*   ebb4f0f (HEAD -> production) Merge branch 'development'
|\
| * 60c1acd (development) Complete feature B and tested.
| * 4a4571e Kick start feature B.
|/
* 8006e3e Merge feature A.
* 31666e2 Complete feature A.
* b0d3c42 Init the example project.
```

# Feature `development` branch

We kick-start new feature implementation based on the `development` branch. If $n$ features are implemented at the same time, we can have $n$ feature branches ongoing. These branches are finally merged into the `development` branch if we want to keep the implementation.

Each feature branch is responsible for a single feature.

Under each feature branch, we’re free to create as many subbranches as we like. These branches are treated as experiments on specific features.

For example, given a feature requirement, there could be more than one way to solve the problem. And sometimes, we don’t know which one is better until we do some experimentation. Creating branches allows us to extend the code in several very different directions.

After we finish the experimentation, we can delete the unused branch using `git reset`. Then, we can clean up the code and have a final check before merging the code into the `development` branch.

Learn how the feature development branches combine into a working development branch.

Getting Started

Basic Command

Behind the Scenes

Essential Techniques

Flow Control

Remote and Collaboration

Handle Conflicts

Undo Changes

Rebase and Cherry Pick

Conclusion

The Working development and Feature development Branches

Working `development` branch

Use `git merge` with `--no-ff`

The Working development and Feature development Branches

Working development branch

Use git merge with --no-ff

Working `development` branch

Use `git merge` with `--no-ff`