Practical Git: Confident Git Through Practice
()
About this ebook
Practice your Git skills using exercises in your own environment. This book introduces concepts in an abstract visual way, and then enforces this learning through exercises - the Git katas.
You will start with basic interactions such as commits and branches, and move on to both internals and collaborative workflows. Best practices are introduced and rehearsed throughout with hands-on exercises. Each topic is supplemented with interactive Git exercises that can be solved using any Git client – either the ubiquituous CLI or one of the many graphical clients so you'll learn in the environment you work in.
The importance of Git is hard to overstate – it is used by 90% of software engineers worldwide and is the de facto standard for version control. Honing your Git skills is guaranteed to make you a better and more efficient developer. Building software can be stressful, but it doesn’t need to be. Practical Git will give you the Git skills you need, and help keep your Git skills sharp. Add it to your library today.
What You'll Learn
- Use Git through scripted exercises and the Git katas
- Understand Git’s graph model
- Troubleshoot common and rare scenarios you may face
- Select and apply the right Git tool for the task
- Maintain and collaborate on Git repositories
- Tweak Git to gain the most from this powerful tool
Who This Book Is For
Anyone who is currently using Git in a copy-paste fashion. It will take you from using Git to knowing Git.
Related to Practical Git
Related ebooks
Beginning Git and GitHub: A Comprehensive Guide to Version Control, Project Management, and Teamwork for the New Developer Rating: 0 out of 5 stars0 ratingsGitLab Cookbook Rating: 0 out of 5 stars0 ratingsGit Best Practices Guide Rating: 0 out of 5 stars0 ratingsThe DevOps Mokitas: Avoid the Elephants in Your DevOps Adoption: A Handbook of Devops Mistakes to Avoid Rating: 0 out of 5 stars0 ratingsLearn JSP in 24 Hours Rating: 0 out of 5 stars0 ratingsGolang for Jobseekers: Unleash the power of Go programming for career advancement (English Edition) Rating: 0 out of 5 stars0 ratingsCross-Platform Desktop Applications: Using Node, Electron, and NW.js Rating: 0 out of 5 stars0 ratingsDocker A Complete Guide - 2021 Edition Rating: 0 out of 5 stars0 ratingsScala in Depth Rating: 4 out of 5 stars4/5Hands-on GitHub Actions: Implement CI/CD with GitHub Action Workflows for Your Applications Rating: 0 out of 5 stars0 ratings150+ JavaScript Pattern Programs Rating: 0 out of 5 stars0 ratingsAlfresco 3 Cookbook Rating: 0 out of 5 stars0 ratingsDocker Deep Dive.: Zero to Docker in a Single Book Rating: 0 out of 5 stars0 ratingsLearn Hbase in 24 Hours Rating: 0 out of 5 stars0 ratingsIntroducing Bootstrap 4: Create Powerful Web Applications Using Bootstrap 4.5 Rating: 0 out of 5 stars0 ratingsGit in Practice Rating: 4 out of 5 stars4/5Puzzles in Java: Shaping Beginners Rating: 1 out of 5 stars1/5Mastering Eclipse Plug-in Development Rating: 0 out of 5 stars0 ratingsInfrastructure As A Code A Complete Guide - 2021 Edition Rating: 0 out of 5 stars0 ratingsPractical Docker with Python: Build, Release and Distribute your Python App with Docker Rating: 0 out of 5 stars0 ratingsThe Well-Grounded Java Developer, Second Edition Rating: 0 out of 5 stars0 ratingsDocker: Build, Test, And Deploy Applications Fast Rating: 0 out of 5 stars0 ratingsConceptual Programming: Conceptual Programming: Learn Programming the old way! Rating: 0 out of 5 stars0 ratingsRy's Git Tutorial Rating: 0 out of 5 stars0 ratingsKubernetes A Complete Guide Rating: 0 out of 5 stars0 ratingsMastering JBoss Drools 6 Rating: 0 out of 5 stars0 ratingsLPI Web Development Essentials Study Guide: Exam 030-100 Rating: 0 out of 5 stars0 ratingsKibana Essentials Rating: 0 out of 5 stars0 ratings
Internet & Web For You
The Gothic Novel Collection Rating: 5 out of 5 stars5/5The Hacker Crackdown: Law and Disorder on the Electronic Frontier Rating: 4 out of 5 stars4/5Coding For Dummies Rating: 5 out of 5 stars5/5How to Be Invisible: Protect Your Home, Your Children, Your Assets, and Your Life Rating: 4 out of 5 stars4/5Social Engineering: The Science of Human Hacking Rating: 3 out of 5 stars3/5Coding All-in-One For Dummies Rating: 4 out of 5 stars4/5How to Disappear and Live Off the Grid: A CIA Insider's Guide Rating: 0 out of 5 stars0 ratingsNo Place to Hide: Edward Snowden, the NSA, and the U.S. Surveillance State Rating: 4 out of 5 stars4/5Remote/WebCam Notarization : Basic Understanding Rating: 3 out of 5 stars3/5Six Figure Blogging Blueprint Rating: 5 out of 5 stars5/5The Beginner's Affiliate Marketing Blueprint Rating: 4 out of 5 stars4/5HTML in 30 Pages Rating: 5 out of 5 stars5/5How To Start A Profitable Authority Blog In Under One Hour Rating: 5 out of 5 stars5/5An Ultimate Guide to Kali Linux for Beginners Rating: 3 out of 5 stars3/5The Digital Marketing Handbook: A Step-By-Step Guide to Creating Websites That Sell Rating: 5 out of 5 stars5/5Podcasting For Dummies Rating: 4 out of 5 stars4/5Mike Meyers' CompTIA Security+ Certification Guide, Third Edition (Exam SY0-601) Rating: 5 out of 5 stars5/5Tor and the Dark Art of Anonymity Rating: 5 out of 5 stars5/5Lying and Lie Detection: A CIA Insider's Guide Rating: 0 out of 5 stars0 ratingsHow To Make Money Blogging: How I Replaced My Day-Job With My Blog and How You Can Start A Blog Today Rating: 4 out of 5 stars4/5Wordpress for Beginners: The Easy Step-by-Step Guide to Creating a Website with WordPress Rating: 5 out of 5 stars5/5Everybody Lies: Big Data, New Data, and What the Internet Can Tell Us About Who We Really Are Rating: 4 out of 5 stars4/5Stop Asking Questions: How to Lead High-Impact Interviews and Learn Anything from Anyone Rating: 5 out of 5 stars5/5Python QuickStart Guide: The Simplified Beginner's Guide to Python Programming Using Hands-On Projects and Real-World Applications Rating: 0 out of 5 stars0 ratingsContent Chemistry: The Illustrated Handbook for Content Marketing Rating: 5 out of 5 stars5/5
Reviews for Practical Git
0 ratings0 reviews
Book preview
Practical Git - Johan Abildskov
© Johan Abildskov 2020
J. AbildskovPractical Githttps://doi.org/10.1007/978-1-4842-6270-2_1
1. Git Intuition
Johan Abildskov¹
(1)
Tilst, Denmark
We’ve all tried it. We get our Git repository in some inconsistent and irreconcilable state. We have found many solutions on Stack Overflow and hesitantly pasted into our command lines. But after each attempt at getting back to a sane state, we feel ourselves sliding further and further away from resolving our Git problem. So we delete our local repository, clone the repository, and start over. I know I have been in that situation more than once. This situation is widespread and is symptomatic of a lack of intuition about how Git works. We tend to choose the path of least resistance, and in Git terms, that means we learn to commit, push, and pull. In some cases, we learn to work with branches, but we become uncomfortable if we veer away from the happy path. This book wants to avoid precisely that. We will build a solid foundation of intuition on top of which we’ll apply concrete commands and solutions. This allows us to first reason about the situations we find ourselves in and then select the right solution from our toolkit. Because we have practiced, we can apply the solution with confidence.
This book wants to avoid precisely that. We will build a solid foundation of intuition on top of which we’ll apply concrete commands and solutions. This allows us to first reason about the situations we find ourselves in and then select the right solution from our toolkit. Because we have practiced, we can apply the solution with confidence.
This chapter will build our intuition at a high level, and we will do our first investigations of how that intuition maps to Git commands and how our workspace and repository reflect these commands.
Version Control
In this section, we will cover what types of issues and what concrete problems we try to solve when we are using Git. This is the foundation and motivation for our entire endeavor. Git is a version control system, but what does that mean in our day-to-day life?
Git is also known as a content-addressable file system. This is something that permeates the entire way Git perceives the world and sets the boundary for what can be done with Git. What this implies though is that Git, at its core, is about managing files. When interacting with Git, we either manage versions of files and directories or investigate the history of a workspace.
Many of us have ended up in a situation like Figure 1-1, where we have a workspace with different versions of a project copied around, based on some arbitrary naming convention. This is how it ends up when we do not actively version control our software.
../images/495602_1_En_1_Chapter/495602_1_En_1_Fig1_HTML.jpgFigure 1-1
Folders in a workspace with ambiguous naming, making it nonobvious what the newest version is and how they relate
This ad hoc approach causes all sorts of difficult challenges. An important point to make here is that none of these issues or challenges are inherent in the problems that we are trying to solve or in the way we work. The tools are freely available; it is simply a choice to work in an improper way. The following is a list of things that are impossible or unnecessarily hard when working directly in the file system:
How does each folder relate to each other?
What is the latest version?
What is the difference between two specific versions?
What is the common base for two product variants?
How do I revert a specific change in a product variant?
At what point in time was this change introduced, and by whom?
How do I merge these two folders?
In Figure 1-2, I show how the same folders could be united in a graph of workspaces. This allows us to maintain a sense of how our software evolves over time.
../images/495602_1_En_1_Chapter/495602_1_En_1_Fig2_HTML.jpgFigure 1-2
The folders from Figure 1-1 maps over in a graph of workspaces. This increases our understanding of the history tremendously
These problems and much more are what Git solves for developers worldwide every day. Before we go in and investigate our first Git repository, we need some of the basic concepts described. Language is a powerful way to convey understanding, so I recommend you try to be as pedantic as possible when talking about Git. This will help you internalize the concepts. When you are a master, you can be as vague as you want.
Basic Git Concepts
Now that I have provided a very rudimentary overview of the type of problems, I will dive into the basic building blocks that we need to build an understanding of Git.
The Repository
When we talk about Git at the high level, we talk about collaborating in repositories. Many software developers share their code as open source on platforms like GitHub or GitLab. Each software project is represented by one or more repositories, depending on what strategy the organization behind the project contains. In many cases, a repository represents a single source component, such as a software library or a product you can download and run on your computer or website.
For most of this book, we will be working in a single repository, and for most of the book, that repository will be local. That is, we will not collaborate or use an online platform to synchronize our repository to.
A repository contains all the information that is available about our versioned workspace. This includes all the commits, all the references, and the entire history of the repository.
Note
New Git users, especially those that migrate in from another version control system such as ClearCase or SVN, worry about the fact that the entire repository resides locally on the developer’s PC. They fear that the repository will take an unreasonable amount of space and that operations will be slow. Going into detail on this topic is way beyond the scope of this book. The short answer is that it is unlikely to become a problem for most workflows, and if it becomes a bottleneck, there are tools and strategies to handle this.
All Git commands run in the context of a repository. This is true no matter if we are running simple commands to interact with our local repository or doing more complex collaborative online commands. All the exercises used in this book run in the context of a repository, and all the work you will do in your day-to-day life does as well. There are two common ways of starting work in a repository. We can either use the command git init to initialize a new local repository without any history and start our work there. This can even be done in a folder with content that is not under version control yet. More commonly, we use the command git clone to obtain a copy of a repository. The source of a repository is most often a private (i.e., Bitbucket on premises) or public (i.e., GitHub cloud) repository manager. If we are using the clone command, we often call it cloning a repository, and we call the local instance of the repository a clone.
The local repository is tied to the source by a configuration called the remote. Unless you are working with open source software, you are unlikely to work with more than a single remote. Open source software is often developed with a so-called fork-based
workflow that we will cover in a later chapter. Collaboration is generally done by pushing and pulling changes between local and remote repositories. How that is done will be covered later.
In short, a repository is the totality of the history of a software project. That is all committed together with metadata. A repository allows you to work with version control locally and collaborate with others through remote repositories.
Note
Some commercial software development works internally using fork-based workflows. This can happen because of different trust levels or low maturity in the software engineering department. It is my opinion that fork-based workflows are an antipattern, or at best a workaround in that situation. Google-based research showed that a key factor in perceived developer productivity is the visibility and availability of source code also from outside the team.
The Commit
The base unit of Git is the commit. Intuitively, a Git commit represents the full state of the workspace at a given point in time. A commit also contains the following metadata:
What commit(s) came before it
The author and committer
A timestamp
A commit message, with information on the content of the commit
Caution
New commits are never created without reason. Their creation is initiated by the user. This can give cause to some frustration for new users, who do not understand why they do not see their changes in shared repositories. What often happens is that the user tries to share all their new code, but without having created a new commit, the shared repository is already up to date without the newest changes. Make sure you commit, before sharing.
The previous commit is called the parent. We can see that we create a graph of commits, tied together through the parent pointers in commits. Commits can have zero, one, or many parents.
The most common scenario is commits with one parent. This happens when we are moving along a single strain or chain – creating one version after another.
The very first commit in a repository is special as it has zero parents. This makes sense as nothing comes before the first commit. The first commit is also often referred to as the initial commit. Many repositories’ first commit has the message Initial Commit
indicating it as the start of the versioned history. If we see large first commits, this is often a sign that the developers did too much work before considering version control. This is bad as version control should never be an afterthought. But you are here, so you will of course never again end up in this situation.
A commit can also have an arbitrarily large number of parents. A commit ends up with more than one parent when branches are merged. We will cover that later, so don’t worry about that now. I say that commits can have an arbitrarily large number of parents, and this is true. The Linux kernel is a fun place to go to see Git used to its limits. Linus Torvalds, the inventor of Linux and Git, has a notorious fondness for the octopus merge where many branches are merged in one fell swoop. This workflow obviously works for the Linux kernel and other open source projects, but my recommendation is that if you end up in a situation where you are merging more than two branches, you are likely doing it wrong.
In short, a Git commit is a bundle representing a workspace that we can retrieve and investigate at any point in time, at lightning speed.
The Branch and the Tag
Git has two types of things, objects and references. The commits that we have described earlier are immutable and in the category called objects. The other category of useful things is called references and is much more lightweight.
At this point, I will introduce two types of references, branches and tags. Both point at specific commits in the graph that we build using commits as described earlier.
The Tag
The tag is the simplest reference in Git. It is simply a pointer to a commit. A commit use for tags is marking the commits that were released with a tag named after the concrete version.
In Figure 1-3, we see a commit with a tag; this allows us to reference to this commit without using its sha.
../images/495602_1_En_1_Chapter/495602_1_En_1_Fig3_HTML.jpgFigure 1-3
A tag is pointing to commit
A tag is never changing. That means that we at any time can back to a commit through a name. It is much easier to understand what is going on when discussing what happened in V1.0
rather than a long