Try out the new version of GitHub Desktop

GitHub Desktop is an officially distributed application that lets you use GitHub's features for version control of source code and files through a graphical user interface, without needing to use commands.
We've covered this in a previous TIPS article—please take a look there as well.

"TIPS vol.32 Let's Try GitHub Desktop"

Let's look at the UI changes.
A major change is that the horizontal history tree that appeared at the top of the screen in previous versions has been removed.
In its place, the buttons have been made larger, and the screen has been streamlined.

Previously, the list was displayed as an accordion on the left side, but it has been changed to a pull-down menu format.
Opening the pull-down opens the list above the current screen. It seems the list can no longer be displayed permanently.

Movement of the Changes and History buttons

The "Changes" and "History" buttons have been moved from the top of the screen to below the repository list.
The layout is now more structured.

The previous "Sync" button has been changed to labels like "Fetch origin" and "Push origin." These labels are now more aligned with standard Git terminology.
What was previously bundled under "Sync" now changes its label depending on the situation.

One major change from the previous version is the behavior when performing "Fetch origin."
In our workflow, we log into a single account from multiple PCs.
While our usage style may be a factor, previously a "Fetch origin (Sync)" rarely failed unless something specific occurred. However, in the new version, if you're editing the same file that has been updated on the remote, you must always commit to your local repository first—otherwise, the contents of the remote repository won't be reflected locally via Fetch origin.
Additionally, after the changes are reflected, you must commit again with a message like "Merge branch 'repository name' of..." (the commit name/Summary can be changed) to incorporate others' changes into your own work.
Since we were accustomed to the previous workflow without these extra steps, this is an area that requires reconsidering our operational approach.

The new app is built on Electron.
There's a menu item that lets you open Chrome's familiar developer tools. (We haven't yet verified what they can be used for.)

Electron is an engine that allows you to build applications using HTML, CSS, and JavaScript.
Since Chromium serves as the runtime, the developer tools look identical to the ones in Chrome. Similarly, Node.js also acts as a runtime.
(Since Electron isn't the main topic this time, we'll skip a detailed explanation.)

By default, GitHub doesn't allow you to push files larger than 100MB to a remote repository.
However, by using a feature called Git LFS, you can handle data over 100MB.

Let's try out how to use LFS on GitHub and see how it looks and behaves in the desktop app after setup.

Git LFS (Git Large File Storage) is, as the name suggests, a feature for handling large files.
To use it, you can't complete the setup using only the Desktop app—you'll need to enter commands in the terminal.
That said, since the Desktop app is built to work with commands, you can also proceed with operations to some extent through the GUI.

We'll proceed with the setup on a Mac.
macOS 10.12.6 Sierra

First, install git-lfs.
We'll use Homebrew for the installation.
(To use Homebrew, you'll need to install Xcode and the Command Line Tools.)
If you can't use Homebrew, install Homebrew first.

Xcode can be installed from the App Store.
The file size is fairly large, so installation may take some time.
Search for it in the App Store, then download and install it.

Launch the installed Xcode and agree to the license agreement.
After agreeing, run the following command.

xcode-select --install

Once the above preparation is complete, proceed with installing Homebrew.
Run the following command.

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Install git-lfs.

brew install git-lfs

Navigate to the repository directory and apply LFS.
You can use the cd command to move there, but you can also open a terminal from within the application.
Right-clicking on a repository in the application brings up several options.
Selecting "Open in Terminal" opens a terminal already navigated to the repository directory.
Once in the repository, enter the command.

git lfs install

Once it's applied, enter the following commands. The filename "large_file.psd" can be anything you choose.

git lfs track large_file.psd
git add .gitattributes

Now commit and push using the standard procedure.
*The filename "large_file.psd" can be anything you choose.
The "LFS test" part is the Summary. You can enter anything you like.

git add track large_file.psd

git commit -m 'LFS test'
git push origin master

That's it.
The commit should now also be reflected in GitHub Desktop.

This time, we introduced the new GitHub Desktop and how to use Git LFS.
GitHub can be used not only for development and code-related tasks, so even designers and others who don't specialize in engineering or code can make full use of it once they understand its operation and structure.
Basically, you can operate it through the Desktop application and use the command line when needed—this will greatly expand your operational range.
Most individual functions aren't too difficult, so without being intimidated, let's continue exploring which features to use for our specific purposes.