Author: Peter Bell
Publisher:  Addison-Wesley Professional

Available from Informit at $119.99
ISBN-13 9780133991772

Duration: 4+ hours

Audience: All developers who need to use version control or collaborate

Rating: 5
Reviewer: Nikos Vaggalis

How does a video course compare to a book when it comes to mastering Git?

I'll admit it. I started watching this set of videos in an unorthodox way. I began with Lesson 5 looking to find an answer to a specific question I had currently in mind : to merge or to rebase? Fortunately it just took a couple of minutes getting to a very clear answer, beating by far the time I would had to spend reading and comprehending a book. It’s an area where video as a medium has the advantage. It allows a rapid way for leveraging the speaker’s experience in presenting the ways an application works. And the good start certainly looked promising.

This video course is actually a recording of Peter Bell‘s live lesson in front of an audience. At this point it has to be said that Peter’s crisp, coherent, confident way of speaking and his use of body language for conveying spoken language, together with his knowledge of the topic, result in a remarkable, and very compelling, experience. I could easily imagine him a politician, ranting in front of an excited crowd. This becomes even more noteworthy when you consider that the video was shot in one take…

 Click for full details on the Informit store

The material is not rushed but smoothly unveiled as we begin Lesson 1: Configuring Git. Did you know that Git had three configuration modes although the Global one is the most used ? The two other options are presented while the most common one is thoroughly examined. That’s a characteristic of the course; trying to cover all available options, those of primary value in detail, and going through the subtle differences between them. It’s a method that makes identifying the suitability of an option for a given job, much easier.

Lesson 2: Getting Started with Git, kickstarts the real work. Here we learn about Staging, Committing, and using History, while discovering why Git is superior to other version control systems, as their differences are brought to light. Everything is well explained, for example how Staging resembles an e-shop’s shopping cart, used as temporary storage before making the actual purchase (Commit).

Lesson 3: Getting Started with GitHub looks at integrating your local repository with Github, not yet for collaborating but for backing it up online

Lesson 4: Files in Git-Renaming, Deleting and Ignoring, advises on the proper way of performing those actions and the potential pitfalls when care is not taken. Peter justifies and explores the making of a choice, like when to Ignore and when not to Ignore, with clear use case examples. 

Even if are  have Git experience prior to taking the course, I would advise against skipping the introductory lessons because I’m certain you'll find it offers new techniques and tricks.

Lesson 5: Branching, Merging and Rebasing is the cornerstone, the single most important lesson of them all. Its comprehension is totally necessary when wanting to work with Git. In this lesson, best practices are covered and answers to practical questions are provided, like ‘when to merge or when to rebase?’
(the insightful answer being ‘you will always merge, the question is whether you rebase first’) , or what’s the difference between fast forward and recursive merge and how to resolve merge conflicts.
In general, this lesson must be re-watched a couple of times to make sure that there is nothing missed

Lesson 6 you can safely skip for the time being as it's on Git's internals and it can be revisited at a later time. Peter himself comments that at this point its usefulness might not be apparent, but later on will become important for projecting a different perspective on Git's philosophy.

Next the course has three lessons devoted to GitHub:

• Lesson 7: Collaborating via GitHub
  
  
• Lesson 8: Reviewing a Project on GitHub
  
  
• Lesson 9: Configuring a Project on GitHub 

Between them they cover how to use GitHub, how to collaborate and share source code online, how to find information on a project, contribute and fill issues to it etc. The essentials, like Cloning versus Forking (most open source projects use Forking) and Pull Requests, are discussed in Lesson 7, while Lesson 8 and 9 are occupied with repo management, how to control the look and feel of your own project, and getting information on other GitHub projects

Lesson 10: Tags and Releases is not only about tagging your production ready releases but how to go about cherry-picking specific commits from another branch. Again, the insight gained by highlighting the differences, providing pro tips and enumerating best practices, as been like that so far, is truly invaluable.

Finally we come to Lesson 11: How to Undo Almost Anything Using Git. Personally I would classify as the second most essential of the course as the various commands for undoing and rewriting history - revert, rest, amend, rebase - are explored.

There’s also a Q&A chapter where Peter answers the audience’s questions on common issues frequently met. ‘When dealing with merge conflict in a large file, how do you find the conflicts?’ or ‘Does Git show the two full, different versions of a file or just the differences?’

Watching these videos made me realize that mastering Git is more an art than a skill. It made me aware of Git’s vastness and complexity as it tries to cater for every case imaginable. There are myriads of switches, options, features that would go silently unnoticed without someone experienced bringing them to light, as this course does. It offers a complete guide to the tool, with tips, tricks, best practices, gotchas included, and even has the edge cases and the obscure internals covered.

I could, metaphorically speaking, say that wrapping the first-rate plot (content) with the actor's (presenter's) outstanding performance, is a box office hit in the making...

 Here is a small sample: