A1.1 Appendix A: Git in Other Environments - Graphical Interfaces

If you read through the whole book, you’ve learned a lot about how to use Git at the command line.
You can work with local files, connect your repository to others over a network, and work effectively with others.
But the story doesn’t end there; Git is usually used as part of a larger ecosystem, and the terminal isn’t always the best way to work with it.
Now we’ll take a look at some of the other kinds of environments where Git can be useful, and how other applications (including yours) work alongside Git.

Graphical Interfaces

Git’s native environment is in the terminal.
New features show up there first, and only at the command line is the full power of Git completely at your disposal.
But plain text isn’t the best choice for all tasks; sometimes a visual representation is what you need, and some users are much more comfortable with a point-and-click interface.

It’s important to note that different interfaces are tailored for different workflows.
Some clients expose only a carefully curated subset of Git functionality, in order to support a specific way of working that the author considers effective.
When viewed in this light, none of these tools can be called “better” than any of the others, they’re simply more fit for their intended purpose.
Also note that there’s nothing these graphical clients can do that the command-line client can’t; the command-line is still where you’ll have the most power and control when working with your repositories.

gitk and git-gui

When you install Git, you also get its visual tools, gitk and git-gui.

gitk is a graphical history viewer.
Think of it like a powerful GUI shell over git log and git grep.
This is the tool to use when you’re trying to find something that happened in the past, or visualize your project’s history.

Gitk is easiest to invoke from the command-line.
Just cd into a Git repository, and type:

$ gitk [git log options]

Gitk accepts many command-line options, most of which are passed through to the underlying git log action.
Probably one of the most useful is the --all flag, which tells gitk to show commits reachable from any ref, not just HEAD.
Gitk’s interface looks like this:

Figure 153. The gitk history viewer.

On the top is something that looks a bit like the output of git log --graph; each dot represents a commit, the lines represent parent relationships, and refs are shown as colored boxes.
The yellow dot represents HEAD, and the red dot represents changes that are yet to become a commit.
At the bottom is a view of the selected commit; the comments and patch on the left, and a summary view on the right.
In between is a collection of controls used for searching history.

git-gui, on the other hand, is primarily a tool for crafting commits.
It, too, is easiest to invoke from the command line:

$ git gui

And it looks something like this:

Figure 154. The git-gui commit tool.

On the left is the index; unstaged changes are on top, staged changes on the bottom.
You can move entire files between the two states by clicking on their icons, or you can select a file for viewing by clicking on its name.

At top right is the diff view, which shows the changes for the currently-selected file.
You can stage individual hunks (or individual lines) by right-clicking in this area.

At the bottom right is the message and action area.
Type your message into the text box and click “Commit” to do something similar to git commit.
You can also choose to amend the last commit by choosing the “Amend” radio button, which will update the “Staged Changes” area with the contents of the last commit.
Then you can simply stage or unstage some changes, alter the commit message, and click “Commit” again to replace the old commit with a new one.

gitk and git-gui are examples of task-oriented tools.
Each of them is tailored for a specific purpose (viewing history and creating commits, respectively), and omit the features not necessary for that task.

GitHub for Mac and Windows

GitHub has created two workflow-oriented Git clients: one for Windows, and one for Mac.
These clients are a good example of workflow-oriented tools – rather than expose all of Git’s functionality, they instead focus on a curated set of commonly-used features that work well together.
They look like this:

Figure 155. GitHub for Mac.

Figure 156. GitHub for Windows.

They are designed to look and work very much alike, so we’ll treat them like a single product in this chapter.
We won’t be doing a detailed rundown of these tools (they have their own documentation), but a quick tour of the “changes” view (which is where you’ll spend most of your time) is in order.

On the left is the list of repositories the client is tracking; you can add a repository (either by cloning or attaching locally) by clicking the “+” icon at the top of this area.

In the center is a commit-input area, which lets you input a commit message, and select which files should be included.
(On Windows, the commit history is displayed directly below this; on Mac, it’s on a separate tab.)

On the right is a diff view, which shows what’s changed in your working directory, or which changes were included in the selected commit.

The last thing to notice is the “Sync” button at the top-right, which is the primary way you interact over the network.

Note

You don’t need a GitHub account to use these tools.
While they’re designed to highlight GitHub’s service and recommended workflow, they will happily work with any repository, and do network operations with any Git host.

Installation

GitHub for Windows can be downloaded from https://windows.github.com, and GitHub for Mac from https://mac.github.com.
When the applications are first run, they walk you through all the first-time Git setup, such as configuring your name and email address, and both set up sane defaults for many common configuration options, such as credential caches and CRLF behavior.

Both are “evergreen” – updates are downloaded and installed in the background while the applications are open.
This helpfully includes a bundled version of Git, which means you probably won’t have to worry about manually updating it again.
On Windows, the client includes a shortcut to launch Powershell with Posh-git, which we’ll talk more about later in this chapter.

The next step is to give the tool some repositories to work with.
The client shows you a list of the repositories you have access to on GitHub, and can clone them in one step.
If you already have a local repository, just drag its directory from the Finder or Windows Explorer into the GitHub client window, and it will be included in the list of repositories on the left.

Recommended Workflow

Once it’s installed and configured, you can use the GitHub client for many common Git tasks.
The intended workflow for this tool is sometimes called the “GitHub Flow.”
We cover this in more detail in The GitHub Flow, but the general gist is that (a) you’ll be committing to a branch, and (b) you’ll be syncing up with a remote repository fairly regularly.

Branch management is one of the areas where the two tools diverge.
On Mac, there’s a button at the top of the window for creating a new branch:

Figure 157. “Create Branch” button on Mac.

On Windows, this is done by typing the new branch’s name in the branch-switching widget:

Figure 158. Creating a branch on Windows.

Once your branch is created, making new commits is fairly straightforward.
Make some changes in your working directory, and when you switch to the GitHub client window, it will show you which files changed.
Enter a commit message, select the files you’d like to include, and click the “Commit” button (ctrl-enter or ⌘-enter).

The main way you interact with other repositories over the network is through the “Sync” feature.
Git internally has separate operations for pushing, fetching, merging, and rebasing, but the GitHub clients collapse all of these into one multi-step feature.
Here’s what happens when you click the Sync button:

git pull --rebase.
If this fails because of a merge conflict, fall back to git pull --no-rebase.

git push.

This is the most common sequence of network commands when working in this style, so squashing them into one command saves a lot of time.

Summary

These tools are very well-suited for the workflow they’re designed for.
Developers and non-developers alike can be collaborating on a project within minutes, and many of the best practices for this kind of workflow are baked into the tools.
However, if your workflow is different, or you want more control over how and when network operations are done, we recommend you use another client or the command line.