Git Version Control

This course is currently not scheduled on the open calendar, but can be organized on request.

Request Course

Duration

2 day(s)

Audience

Individuals who require a basic understanding of Version Control with Git and how it may be used to enhance the quality and efficiency of the software development process within an organization. The intended audience may include, but is not limited to, professional software engineers, technical architects and team leads and ALM or DevOps teams.

Prerequisites

No prerequisites

Objectives

The purpose of the course is to help you gain knowledge of the Git terminology, usage and basic concepts, and help you in realizing an optimal software development workflow using Git.

Methods

Instructor-led workshop with practical exercises.

Description

Git is a Free and Open Source (FOSS) Version Control System (VCS) to help management of a project's sources. It was originally built with the complexity of the Linux kernel in mind. This makes the software extremely powerful, but also difficult to master. Git uses a lot of difficult to understand terminology and usage patterns. In a sense, you can regard Git as a "toolbox", where each command can be used in multiple ways.

To tackle the rather steep learning curve of Git, we provide this course to get you started in the world of Git, but also continuing to some of its more advanced usages. For example, the first chapter will focus on the basic commands and workflows, such as adding and committing files, exploring the history, etc... In the next chapters we continue to branching techniques, merging and rebasing. Finally we finish with remotes and security configuration. Thus the course provides an added value for both absolute beginners as well as intermediate Git users.

Depending on the audience more or less focus can be put on the essentials and/or exercises. Feel free to contact us if you prefer the course with less exercises in a single day.

Git Version Control
- Getting Started
  - Course Objectives
  - Agenda
- Introduction
  - What is a Version Control System?
  - Revisions
  - Generations of Version Control
  - Local Version Control
  - Centralized Version Control
  - Distributed Version Control
  - Git
  - Online Git Services
  - Git Commands Toolbox
  - Command Line Interface versus GUI
  - Installing Git
- Basic Commands
  - Manual Pages
  - Configuring Git
  - Initializing a Repository
  - Working Tree States
  - Repository Status
  - Adding Files
  - Committing
  - Commit Identifiers and HEAD
  - Displaying History Logs
  - Using Gitk
  - Resetting
  - Checkout
  - Removing Files
  - Moving and Renaming Files
  - Gitignore
  - Stashing
  - Specifying Revisions
- Branches
  - What is a Branch?
  - Purpose of Branches
  - Merging Branches
  - Listing Branches
  - Creating Branches
  - Switching Branches
  - Detached HEAD
  - Removing and Renaming Branches
  - Practical Branching Strategies
  - Specifying Revisions Revisited
- Merging
  - Merging Rationale
  - Branch Types for Merging
  - Performing a Three-Way-Merge
  - Merge Conflicts
  - Resolving Merge Conflicts
  - Useful Merge Arguments
  - Using a Mergetool
  - Fast Forwarding
  - Octopus Merges
  - Other Merge Strategies
  - Rebasing
  - Rebasing vs Merging
  - Squashing
  - Interactive Rebase
  - Cherry Picking
  - Merging Challenges
- Remotes
  - What is a Remote?
  - Creating a Remote Repository
  - Transfer Protocols
  - Cloning
  - Configuring Remotes
  - Remote and Tracking Branches
  - Fetching
  - Pulling
  - Pushing
  - Forking
  - Pull Requests
  - Forking-Pull Requests Overview
- Security
  - Remote Access Using SSH
  - Signing Commits With GPG Keys
- Extras
  - Creating Command Aliases
  - Filtering Branches
  - Creating Patches
  - Additional Commands
- References
  - Useful References

Details