Name: Git Essentials: Developer's Guide to Git
Author: David Landup

Course Ebook (PDF)

Course Ebook (EPUB)

Git Cheatsheet PDF

Git Essentials - Developer's Guide to Git is a course for everyone, beginner to advanced in software engineering, written to get you up to speed with the world's most prevalent version control system. Git has become synonymous with Version Control Systems (VCSs) and is expected to be under the belt of every developer as one of the most basic tools used to coordinate software development.
Oftentimes, developers aren't fully acquainted with Git but, due to its simplicity in certain areas, it's easy to work with some basic operations without really understanding what's going on. This more often than not leads to constant searching for commands, browsing StackOverflow and Google endlessly, and ultimately confusion when the answers use terms that aren't as beginner-friendly as some of the basic commands are.
The course assumes no prior experience with Git and applies to all languages and operating systems. It covers everything you need to know, from why version control systems are considered fundamental tools and the basics of Git to advanced operations with best practices and a printable PDF cheat sheet to encapsulate all of that content in an easy-to-lookup list of common commands, tasks and errors you'll use in your day-to-day career.

David Landup

François Dupire

Introduction

<h3 id="whatissourcecodemanagement">What is Source Code Management?</h3>
A good question to begin with would be:
<blockquote>
What is Source Code Management?
</blockquote>
Source Code Management could be defined as the process of tracking modifications in the code of a software solution. It's worth noting that Source Code Management and Version Control refer to the same thing. You'll come across &quot;SCM&quot;, &quot;VCS&quot;, &quot;Source Control&quot;, &quot;Version Control&quot;, &quot;Revision Control&quot;, etc. interchangeably, in the context of software development.
Version Control itself, can also have a broader meaning - controlling the versions or changes of anything. A curious use case of Version Control Systems would be keeping track of changes in the legislation and laws of a country.
In robust systems, where even small changes can impact a lot of other modules, keeping track of them is paramount. Knowing who made the change, with a timestamp associated with it, and a clear view of what was changed would be able to change the way we bring about laws.
It's not unheard of for legislators of to debate wrong law proposals, and only realizing that they're discussing an outdated version after wasting valuable time, simply because the documents given to them and the changes made to them weren't tracked properly.

Source Code Management - SCM

Now's the time to get started with our first steps in using Git. First of all, we'll install it on Windows, MacOS and Linux, depending on your personal preference. Then, we'll configure it with some basic configurations, such as specifying which user we are to avoid retyping the credentials on each operation that requires authorization. Finally, we'll create a new file and commit it to our repository!
<h2 id="installinggit">Installing Git</h2>
First, let's install Git on our computer. The three following sections explain how to do it on Windows, Mac OS, and Linux, respectively. Feel free to jump right to your favorite operating system.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 Please note: The version used throughout this course is 2.30.0., which was released on the 28th of December, 2020. As significant releases of the tool get pushed, we'll update the course as necessary.

 </div>
 </div>
 <h3 id="windows">Windows</h3>
To install Git on Windows, we'll navigate to the official <a href="https://git-scm.com/download/win">git-scm</a> website's download page. Depending on your system, you can choose a portable or regular setup file. We'll go with the adequate version of the regular setup file.
Once downloaded, we can run the <code>exe</code> file. Then, a wizard will guide us through the installation step by step. We'll go with the default options here.

 Getting Started with Git

Now that we've installed git and configured some of the basic options - we can learn how to use it. We've briefly gone over the creation of a repository in the last lesson, as well as creating a file, adding it to the staging area and committing the change. To understand what was going on under the hood, we'll need to navigate through the concepts of the repository, index, staging area and commits, also mentioned briefly in Lesson 2.
Armed with those, we'll already have a working knowledge of Git, and thus will be able to use it to keep track of changes made in small projects.
<h2 id="demoproject">Demo Project</h2>
To help us out with visualizing what's going on, we'll make use of a small demo project. We're going to implement a simple <code>Calculator</code> class in Java, and use this project throughout the course.
Don't fear if you don't know a single thing about programming in Java, this will be kept quite simple, only to serve as a support for the course, and to visualize the changes. You can supplement the course with any language and any project you're working on - be it a new one or an existing project you'd like to start performing version control on.

The Basics of Git

First, what's a branch? As we said in the introduction, the idea behind branching is to manage multiple versions of a codebase, and that's what a branch is: another version of that codebase.
Similar to how commits are versions/snapshots of the codebase - each branch is a version of the codebase. However, each branch has a set of commits that lead to that state.
Let's say we're working with a fellow developer on a repository. For now, let's assume we're working on the same computer. They're fixing a very important bug, while we've been assigned the task of implementing a new feature.
We won't be ready for a while and can't take the chance of disturbing our colleague by committing some unfinished work. In the best-case scenario, we could accidentally change some behavior which breaks their code even more. In the worst-case scenario, since we don't usually package, test and refactor the code while writing it for the first time, we can break the entire project.
But still, we would like to commit our significant changes along the way and not wait for the bug to be fixed before recording our changes to the repository.
Initially, this seems like a counter-intuitive set of wishes. We don't want to disturb the existing repository, but we also want to commit changes to it along the way, other than just changes in the local repository.

Jovana Ninkovic

Branches

At this stage of the course, we've built a solid understanding of how to manage a local Git repository - how to create one for a project, how the working directory and staging area work, how to add and remove branches, switch between them, commit changes, as well as merge and rebase the work we've done so far.
We're equipped with the knowledge that allows us to follow multiple parallel tracks of work, but also cooperate more easily with our colleagues. However, one thing that wasn't so convenient is that all the work so far has been done on the same machine. Let's face it, that's not very realistic.
Sure, we've had branches to separate workflows, and we've simulated our colleagues working on different tasks by switching between branches and committing code changes, but it was all done on the same machine.
Now is the time to evolve towards working with remote repositories, so that each collaborator can use their own machine, at a different place, at any given time. This will be the focus of this lesson.
Through this lesson, we'll learn what a remote repository is and how we can work with them. We'll then take a look at how to set one up for free using GitHub, and after that, we'll take a look at how we can set up a link between a local and a remote repository.

Remote Repositories

Now that we know how to deal with remote repositories, it's time we discuss how real collaboration takes place on a software development project that uses Git as its VCS.
In this lesson, we're going to explore a few strategies, called branching models, to manage such a project. In the end, we should be able to tell the main benefits and downsides of each model. Also, we should be able to tell if one of those strategies matches the needs of a project we're working on or not.
<h2 id="whatsabranchingmodel">What's a Branching Model?</h2>
For starters, let's define what a branching model is, also known as a branching strategy or workflow.
<blockquote>
A branching model is a series of rules one must follow when working on a software development project to ensure easier collaboration.
</blockquote>
In much the same way social etiquette is used to enforce certain behavioral rules, teams all around the world find the best way they can define their workflows to fit their project and team structure. It's called a branching model because it often involves using branches in a certain way, following certain conventions and rules.
Using a branching model is not at all mandatory, but it can facilitate working in parallel on a project, and integrating each other's developed features.

Branching Models - Strategies

We're starting to have a really good grasp of how to use Git properly. We know the commands used to work with the local repository and branches therein, how to interact with remote repositories and branches, and how to collaborate effectively with other people through the use of branching models.
So, now, we'll talk about a few Git operations we didn't mention before. Those are more advanced, less commonly used operations, compared to the basic <code>add</code>, <code>commit</code>, <code>pull</code> and <code>push</code> operations.
Although they're not as commonly used as the first category, they're nonetheless important and very useful when it comes to working with Git.
We'll cover a few new operations in this lesson:
<ul>
<li>The <code>stash</code> operation that allows us to save uncommitted changes, for later reuse, in a dedicated space of the repository.</li>
<li>The <code>tag</code> operation which allows us to label a commit to retrieve it easier, instead of using commit hashes.</li>
<li>The <code>reset</code> and <code>revert</code> operations, for when we're not happy with the work we've currently achieved and want to rollback some modifications.</li>
<li>The <code>cherry-pick</code> operation, which allows us to copy the content of a single cherry-picked commit of another branch. A practical, but risky way of selectively picking and applying changes from another branch.</li>
<li>The <code>git diff</code> operation, which allows us to take a look and compare differences between files.</li>
<li>The <code>commit --amend</code> operation, which allows us to modify the latest commit.</li>
<li>We'll see how to perform an interactive rebase, which is a fine-grained version of the rebase we already know.</li>
<li>Finally, we'll take a look at how to perform interactive staging, which is also a fine-grained version of staging files like we usually do.</li>
</ul>

Advanced Operations

We've gone through a lot so far - the basics of working with Git, working with branches and remote repositories, as well as some advanced operations. We've also covered a few standard ways to use Git on a collaborative project, and included some good practices there.
In all of these lessons, we've tried including notes and disclaimers about certain operations and how to use them responsibly. Such as, which files to include in the <code>.gitignore</code> vs <code>exclude</code> file, or which things to look out for when rebasing.
Now is the time for some general good and bad practices. This will be a more opinionated lesson, filled with the personal experience of the authors and the way they see things right now. They may change in the future, in the light of new knowledge. Be sure to take a step back after reading this lesson and decide for yourself if that makes sense.
<h2 id="commitoften">Commit Often</h2>
What does committing often mean? That means our commits should be relatively small. That facilitates going back when making a mistake.
Let's consider our Calculator project. If we'd implemented all the operations in the same commit, and the fourth operation had a mistake in it. It would've been difficult to just roll back that mistake, or rather - it would be impossible. We'd have to roll back other features as well, which might be important for someone else to use.

Good/Bad Practices

Online education is spreading through the world, and is becoming an increasingly important part of many lives. We believe that accessible, high-quality resources can help empower people that build tomorrow, and remain guided by that goal.
At StackAbuse, we believe that learning is not a one-stop time investment. It's life-long. Especially in the volatile and rapidly changing world of Computer Science and Software Engineering. So, we've pledged to update our courses, guides, and other upcoming material to keep the pace of progress in the field. Software is updating - it's only fitting that learning resources are updating as well.
Thank you for purchasing our Git Essentials - Developer's Guide to Git course! We hope that it has brought a ton of value to you so far, and know that it will continue to do so as you dive further in to this topic.
We believe that high-quality resources and education is community-driven and that minor (or major) contributions from each member results in a wonderful learning oasis. For this, feedback is crucial.
<blockquote>
Is there something you specifically liked in the course? Or more importantly, is there something you disliked? Did you feel like some examples could've been more detailed? Was something lacking? Were the code explanations clear and understandable? Do you feel more confident with these tools than before? Have you had the chance to use new versioning control skills for a project?
</blockquote>

Thank You for Supporting Independent Publishers and Online Education

Git Essentials: Developer's Guide to Git is a course for all developers, beginner to advanced, and written to get you up to speed with the world's most popular version control system. Git has become synonymous with VCSs and is expected to be in the wheelhouse of every developer as one of the most fundamental tools used to coordinate software development.
Stop turning to Google every time you need to commit some code, create a feature branch, or tag a release. With this course, you'll actually learn Git instead of just memorize the commands. We're all guilty of copy-pasting Git commands from the first result that shows up in Google, but the important question we're missing is - is that really the right thing for our situation? Learning and understanding these commands will help you become a more productive member of your team.
This course assumes no prior experience with Git, it applies to any operating system, and will work with any source files that can be version controlled. It covers everything you need to know, from why version control systems are considered fundamental tools to the basics of Git to advanced operations and best practices. The course also includes a printable PDF cheat sheet to encapsulate all of that content in an easy-to-lookup list of common commands, tasks, and errors you'll encounter in your day-to-day work.

	Course Ebook (PDF)(3 MB)		Enroll to download
	Course Ebook (EPUB)(2 MB)		Enroll to download
	Git Cheatsheet PDF(181 KB)		Enroll to download

Git Essentials: Developer's Guide to Git

Overview

Lessons

Downloadable Resources