Git for Windows: Step-By-Step Mastery using Commands and GUI
This course is designed to be a comprehensive, step-by-step approach to learning the Git source control specifically designed for Windows users, which means no prior knowledge or experience is required but students will emerge at the end with a very solid understanding and hands-on experience with Git and related source control concepts. Since this course is design for Windows users in mind, we will cover both command line and graphical clients for Git while learning the underlying concepts. If you use other operating systems too, most of the concepts will transfer over without much effort.
Course Introduction and Overview provides an introduction to this course and the Git source control system and sets the stage for the rest of the course.
After the introduction, this first thing we do is run through the Installation process. If you don’t want to watch installation videos, you can simply follow the installation notes at the end of that section.
For those not familiar with the command line or Bash shell environment, I provide a handy Git Bash section for those interested.
Quick Start a very quick (15 minutes), hands-on introduction to Git. We start off by signing up for GitHub, creating a repository there, the makiing a local copy (clone), local changes (add/commit) and then update GitHub with our changes (push). This is the most common workflow developers will do using Git.
Once we have worked through the basic add/commit/push workflow, we can do the same steps, and a few more, using the Windows Command Prompt and PowerShell— really to show how the Git-related command work identically regardless of the shell used.
To prepare for the rest of the course, and a more common developer setup, we will install and configure a Text Editor (Atom) to work seamlessly with Git.
In Basic Commands, we walk through all the foundational commands needed to start a new project managed by Git (or enable Git for an existing project) all the way through making commits, including common file operations like moving and deleting files. We also cover how to exclude the wrong files from accidentally being committed and how to review your repository’s history.
With a strong foundation in place, we explore ways to make Comparisons in Git, including all the different local states, between commits, and between local and remote repositories.
We give great attending to Branching and Merging in Git. We start off with the simple “happy path” and learn about “Fast-Forward” merges and how to control them. The we walk through common “automatic” merges. Then, we cause trouble on purpose so we can step through resolving conflicting merges with our visual merge tool. Finally, we work with branches on the GitHub hosting service.
With a solid foundation in place using Git on the command line, we will look at various Git graphical clients starting with the official Git GUI client on Windows. With Git GUI, we cover many of the same commands, but simply using the graphical client instead of the command line.
Another way to interact with Git is via the Windows Shell or Windows File Explorer in which we can use the default Git integration provided by Git for Windows and even deeper integration using TortoiseGit.
Presentations provide audio/video training of conceptual ideas. Since few like slide-ware presentations, slide-presentations are kept to a minimum.
Screencasts provide a video of the instructor’s computer system with any actions, commands, or screens displayed and narrated. There is over 6 hours of screencast based video training in order to step through each command or action in sufficient detail.
All videos are available in high quality 1080p / Full HD resolution for sharp and clear viewing on modern desktops and tablets although resolution delivery is dependent on student’s device capabilities detected by the Udemy video player.
Several attachments and document lectures throughout the course provide supplemental information, illustrations, or other reference material.
This course will expand periodically to include more topics, supporting materials and bonus content! Some content may be in direct response to student feedback or discussions — so get engaged with the course discussions (Q&A) feature!
A general overview of the course objectives. This course takes a step by step approach to the fundamentals of using Git and GitHub within the Windows 10 environment.
A detailing of the target audience for this course. Specifically, students new to Git using the Windows environment. The videos are short and to the point, using hands on demos to explore concepts.
A short bio of the instructor, Jason Taylor.
A quick overview of why you should be using version control! Source control is a centralized backup system that not only preserves code, but a history of changes to the code. This enables many critical features that improve any development cycle.
A quick introduction to the theory of how Git works.
A quick explanation of why this course starts first from the command line. Many Git features work best on the command line. And, even if you do use graphical clients, understanding the commands that make those clients work makes any developer's job a lot easier.
A general overview of what installation videos will be featured in this section. Students should feel free to skip over or skim through these lectures as long as they are confident in their setup.
A quick look at the importance of 64 vs 32 bit in installing software for your computer.
A quick guide to installing Google Chrome and setting it up for the rest of this course.
A quick guide to creating shortcuts to easily access the command line environment within windows.
A guide to installing and setting up Git and the Git Bash environment in windows for use as the heart of this course.
A quick introduction to the internal guide provided within the Git Bash environment.
A quick guide to providing the minimum configuration needed to be able to start using Git on Windows.
A text-based guide on how to configure your system for this course.
A quick explanation of the critical concepts of this section of the course.
A guide to using the Git bash terminal environment to navigate through your file system.
A guide to how Git bash functions within Windows and how to use the help command in order to get an overview of the commands you may want to use.
A basic overview of how to manage files and folders within the Git Bash terminal environment.
Most students won't ever want to use the command line based text editor VI, but knowing the basics will help get you out of a sticky situation if it's ever forced upon you!
A final guide to file management within Git Bash, showing how and where to set up a folder to contain all example projects we will be working with in this course.
An overview of the goals of going through this quick start git workflow.
A short guide on setting up a GitHub account. Having a remote place to store your files is a vital part of source control, as it provides the best type of backup for these projects. Feel free to skip if you already have a GitHub account.
A quick guide to creating your first remote repository on GitHub.
A quick explanation of how to get your remote repository onto your local system. This is the most important step when using a "starting remote" workflow in Git.
Creating our first commit on our local system in order to better understand the workflow between Git and Git Hub.
Editing a file in order to simulate work being done locally on our Git repository.
Completing the workflow cycle through backing up our progress to our remote hosting service, GitHub.
A quick overview of the topics covered in this section on the Windows Command Shell.
Getting used to the way the Windows command prompt functions in comparison to the bash environment.
Setting up the default Windows program, notepad, to be the default editor in the command prompt to avoid using the VI editor.
Starting a new repository locally in the Windows command prompt environment.
Creating the initial commit for our local Git repository in order to legitimize it as a repository.
Setting up and associating a remote repository with our local repository using the windows command prompt.
Using the third command line option, Power Shell, in order to further modify our Git repository.
A quick explanation as to why we will be installing the HTML based text editor Atom to do more advanced work in the rest of this course.
A quick guide to installing the Atom text editor and integrating it into all three command line interfaces: Git Bash, PowerShell, and Command Prompt.
A quick guide to modifying the look of text in Atom to make it easier to work with for the rest of this course.
Further configuring Atom to work well within Git Bash.
A quick-start guide to using the feature set of the Atom text editor.
A quick guide to setting up and using Atom from within the windows file explorer.
An overview of the Git basics that are introduced in this section.
A guide to setting up SSH authentication in order to establish a more secure connection between our local and remote repositories.
A quick guide to improving the security of our repositories by moving them over to our newly set up SSH authentication method.
A guide to creating a new repository initialized with the basic structure of a web page.
A guide to more efficiently add files to our Git repository using recursion, before finally pushing up those changes to our remote repository.
A guide to the slightly more complicated nature of deleting files within Git while retaining Git's file tracking.
A guide to the similarly complicated nature of moving files within Git while retaining Git's file tracking.
Understanding the history provided by the Git log command.
A guide to simply our history commands into simpler custom aliases that perform the same actions.
A guide to automatically excluding files that you do not wish to track with Git.
A guide to undoing changes you don't want using Git's history management.
Backing up all of the changes we've made within this section, so to make sure we all start on the same foot in the next sections.
An overview to the types of Git comparisons we will be doing in this section.
A guide to installing and integrating the comparison and merge tool, P4Merge.
Setting up our repository with easily understandable changes to use as comparison examples throughout the next few lectures.
The first basic level of comparison; comparing files within our local environment.
More advanced local comparisons with previous changes in our repository.
A detailed explanation of how the Git show command is used to understand our Git commit history.
Comparing changes between two arbitrary commits in our local Git repository.
Using our local system to compare changes between our local and remote repositories.
Cleaning up our changes in order to make things ready for the next section.
An overview of the types of bracing we will be working with in this section.
A quick overview of the simple way to create and use branches within Git.
Learning how to preserve branches in history by disabling fast forward merges.
A guide to getting the most out of automatic merges in our Git repository.
Creating conflicts in order to show how merging will most often work within an active (chaotic) development environment.
Deleting branches in order to clean up the history of our Git repository.
Creating forks of remote repositories in order to work with them. This is the most common method used when getting started working on software projects, especially open source ones.
Learning how to use GitHub itself to create and manage branches for our Git repository.
Learning how to compare and merge local and remote repositories together using pull requests.
Resolving conflicts created in the local repository when pulling from the remote repository using our difftool.
Cleaning up our GitHub repository by deleting unnecessary branches.
A quick overview of the goals of this section on the Git GUI.
A quick-start guide to the setting up and using basic features of the Git GUI client.
A guide to the tools in Git GUI, specifically focusing on integrating our Atom text editor to the Git GUI environment.
A guide to a basic Git workflow within Git GUI using an existing repository.
A guide to using Git GUI to create a fresh repository.
A guide to making and then undoing those changes within our Git GUI client.
Setting up our GitHub repository with our new repository through the Git GUI client.
A guide to starting remote by creating a repository on GitHub and then cloning it down to our local system using the Git GUI client.
A guide to using Git GUI to create branches on our local system.
A guide to integrating branches between GitHub and our local Git GUI client.
A guide to viewing our repository history, as well as blame, from within our Git GUI client.
Configuring our Git GUI client to be better suited to our workflow for future projects.
Windows Shell (Windows GUI) and Tortoise Git
A look at how we will be integrating Git into the Windows Shell (Windows GUI).
A quick guide to setting up the Git integration into the Windows Shell that we will use throughout the rest of this course.
A guide to further integrating Git features into our Windows Shell using Tortoise git and PuTTY.
Configuring the appearance and function of our Git integration within our Windows Shell.
A guide to using Tortoise Git to work with our existing Git repositories.