Git & GitHub Masterclass
4.4 (578 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
5,151 students enrolled

Git & GitHub Masterclass

Add real world development team skills for version control and source control to your resume & programming arsenal!
4.4 (578 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
5,151 students enrolled
Last updated 2/2020
English
English [Auto]
Current price: $47.99 Original price: $79.99 Discount: 40% off
1 day left at this price!
30-Day Money-Back Guarantee
This course includes
  • 11.5 hours on-demand video
  • 1 article
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Use Git and GitHub in the way that modern development teams use them.
  • Understand the ideal structure of a repository.
  • Learn how GitHub will enable great collaboration in a development team.
  • Master the git commands that will help you explore any repository.
  • Leverage Markdown in your GitHub repositories.
  • Publish your repositories in public websites through GitHub Pages.
  • Feel comfortable contributing to a repository, whether open source or as part of your job.
  • Understand how GitHub is the foundation for more advanced development practices such as CI/CD and DevOps.
Course content
Expand all 73 lectures 11:34:17
+ Getting Started with Git
10 lectures 01:02:23

Before diving deep into using Git and GitHub, you must understand what Version Control is, and so, in this lecture we give you an introduction to its main advantages and what you can expect when using it

Preview 06:37

In this lecture you will install Git on your Windows computer and ensure that it is ready for you to use.

Install Git on Windows
04:31

In this lecture you will install Git on your Mac computer and ensure that it is ready for you to use.

Install Git on macOS
03:12

In this lecture you will install Git on your Linux computer and ensure that it is ready for you to use.

Install Git on Linux
04:18

Now that you have Git installed on your system, it is time to configure the git bash so that it displays more useful information as we work with the command line. We will then need to configure the bash profile and add some more code that will improve the experience when using Git

Setup Git Workspace on Windows
08:15

Now that you have Git installed on your system, it is time to configure the git bash so that it displays more useful information as we work with the command line. We will then need to configure the terminal and add some more code that will improve the experience when using Git

Setup Git Workspace on Mac/Linux
07:58

In this lecture you will create your first Git repository directly from the terminal or bash. This means creating a new directory, creating a couple of files in there, and also commit the additions and changes that we do on those files.

Preview 07:21

You have made your first commits, created a repository directly from the terminal and it is now tracking changes to your source code. But do you understand what is actually happening? In this lecture we will describe the process in a bit more detail, so you understand the process from the working directory, to the staging area, to the repository itself.

Understanding The Full Commiting Process
04:48

Now that you are tracking your files, we can start to take advantage of the fact that we now have a source control tool implemented in our workflow. Once of the most important features of any source control manager is the ability to compare different versions of a different file. So in this lecture we learn how to compare a previous version of our file with the current version, so we can see what changes we have made.

Reviewing File Changes
04:44

There are a few configurations that we have missed so far. When making our commits, Git may not have all the crucial information set just yet, which is why it is important that we configure things like our user name, the email that will be used to establish you committed the changes, and also, what code editor will be used directly with git, which is particularly important if we want to make commits that contain even more text in the commit messages.

Missing Git Configurations
10:39
+ Getting Started with GitHub
6 lectures 39:39

Now that you have started using Git, we will start using GitHub as well, but before we dive into the GitHub tool, we first need to undestand how does it fit into the Git environment, how would we use it, and how does it differ from Git itself.

Preview 08:26

In this lecture you will create your GitHub account and start exploring the website. You will then create your first repository over on GitHub, which won't mean that it substitutes the local usage of Git.

Create your GitHub account
07:59

In this lecture you will send your local repository to the repository you created over on GitHub, this will actually be a single repository that exists on more than one computer. So this is all about continuing to use Git commands and Git working together with GitHub

Pushing your Local Repo to GitHub
06:14

GitHub is not an editing environment, but for small modifications it can be of use. In this lecture we will change the code that we have been using a little bit, and make sure that we commit the changes.

Editing Code and Commiting from GitHub
04:42

So GitHub can make changes and commit them to the repository. In this lecture we learn how to get those changes in our local repository, since it would now be out of date, since the remote made some additional changes.

Pulling from the Remote
05:46

Working with a remote adds another level of complexity to our version control that we hadn't seen locally: we may miss updates that others make in the remote. So git status becomes of great importance to check for updates that have happened outside of our local repository.

Check for Changes with Git Status
06:32
+ Fork and Clone
7 lectures 01:12:23

You now know more about GitHub as well as about Git. The next step is to learn how GitHub can help you colaborate with other developers, even those you don't know. Here forks play an important part, and it will be all about copying a repository into your own GitHub account, but before diving into that, we need to introduce the concept and understand how that would work.

Intro to Forking GitHub Repositories
05:59

Now that you have a fork of someone else's repository over on your GitHub account, it is time to "download it" into your local computer so that you can use Git locally and your own code editor to work on the project.

Cloning a Repository
08:42

After cloning a repository a great thing to do is explore the logs that give you information about the versions that the repository has had over time, and exploring the logs is a great way to do so.

Exploring Git Logs
09:49

You have forked a repository and started exploring the history of the commits made, but digging deeper into the individual changes made to individual files is also of great importance.

Getting Commit and File Details with Git
12:54

All the things we have learned about exploring details from a repository are deeply integrated into GitHub, which just leverages what Git has to offer and presents the information in the website. In this lecture we explore file details, blames, and commit history directly from GitHub.

Exploring Commit and File Details from GitHub
10:53

Making changes to a repository that you cloned is the same as making changes to a repository that you created. We also explore what it means in the context of collaboration, and get a sneak peak at what pull requests are.

Preview 10:34

Version Control is about being able to go back to a previous version of our code if things are no longer working the way they were supposed to. So during this lecture we focus on the steps that you can perform to go back to previous versions of unstaged files, staged files, and even commited files.

Undoing Changes and Reverting Commits
13:32
+ Working with Branches
9 lectures 01:09:30

In this lecture we explore the main good practices when working with branches for ensuring that you always have a working final version of your project, and that you correctly structure your branches in a way that is easy to understand the relationship between them

Good Version Control Practices
07:19

In this lecture we will dive deeper into what a branch is, and how are we going to be using them to add new code that is related to a certain bug fix or some new feature that must be added to the project.

What is a Branch?
06:34

In this lecture we finally create a branch inside of our repository. This new branch is going to be the dev branch that I mentioned in the previous few lectures. We will also create a feature branch and make sure that it doesn't affect the other branches until we have tested. Just for fun, we will add some Bootstrap to an html file that we have used before.

Creating a Branch with Git
09:51

In this lecture we finally create a branch inside of our repository. This new branch is going to be the test branch that I mentioned in the previous few lectures. We will also create a feature branch and make sure that it doesn't affect the other branches until we have tested. Just for fun, we will execute the beginnings of another pull request.

Creating a Branch with GitHub
07:23

In this lecture you will learn how to use the gitignore files so that some of the files in the working directory are ignored by git and hence are not added to the repo.

Adding a gitignore File
12:11

In this lecture we will push the local branches to the remote so that it contains all of the branches that we have created, and will also checkout to the remote branches locally (and track them) so that both repositories contain the same code and git information about all the branches

Syncing Branches
06:51

In this lecture we will take a look at a neat git tool that allows us to graph the relationship between the branches and the commits, as well as understand where and whit which commits did merges happen.

Graph the Branches on the Terminal
05:01

Merging branches is a very important step. This lecture covers how you can merge branches using Git directly from the terminal, but also mentiones that there might be more complex scenarios in the future.

Merging Branches in the Terminal
04:27

Merging branches is a very important step. This lecture covers how you can merge branches using GitHub (where this is called pull request), but also mentiones that there might be more complex scenarios in the future.

Pull Requests in GitHub
09:53
+ Merge Conflicts
7 lectures 01:05:43

Once we have executed some merges without any issues in the process, we will take a look at when would some conflicts happen, since merges may not always be executed automatically by git

When do Merge Conflicts Happen?
05:42

In this lecture we will now talk about the types of merges that we have already executed, so we understand how the may be graphed in the terminal when executing the log command, and also, so we identify the reason why no merge conflicts have happened just yet.

Types of Merges
06:26

In this lecture we prepare a scenario that results in a merge conflict, and inspect how is it that the conflict is handled and depicted by git from the terminal and in the file itself.

A First Merge Conflict
13:26

In this lecture we will solve the conflict that we prepared in the previous lecture so the merge can finally happen. Then, we will try to push the new merging commit to the remote, only to find that there are a couple of other simple merge conflicts that we have to solve first.

Solving the Conflict
10:08

In this lecture we build over to a merge conflict on GitHub when executing a pull requests, du to our different edits to the same files from two different repositories that we forked from the original repo.

Merge Conflicts on GitHub
10:31

In this lecture we solve a merge conflict on GitHub that generatedn when executing a pull requests, we will also have a sneak peak to collaboration directly from the GitHub website by adding comments from the pull requests and using markdown a little bit.

Solving Merge Conflicts on GitHub
08:14

In this lecture we will add some tags to some specific points in our repository's history so that it is easy to identify new versions or releases of the project. Everything will be pushed over to GitHub so releases and tags exist there too.

Preview 11:16
+ Collaboration in GitHub
4 lectures 01:00:40

This lecture is going to prepare you for this and the next section, you will learn to add collaborators to a private GitHub repository, and to clone the repository to a Google tool called Colab, where you can edit the files (python notebooks) that we will be using.

Colaboration on Private Repos and Cloning to Colab
21:28

In this lecture we will learn how to protect branches in GitHub so no merges can happen without first some reviewers approving the changes. This adds to the pull requests a new level of protection, even from the collaborators that have been added to the repository.

Protecting Branches on GitHub
15:21

Pull requests are very imortant, so there have to be some limitations to how they are performed, which is why we have protected some of our branches. In this lecture we learn how reviewers can comment on the pull requests, request changes, and eventually aprove them so the merge can occur.

Requiring Reviews in Pull Requests
08:46

In this lecture we will create some issues that describe a problem that we may have to solve with our project, later, when we commit changes, we will learn how we can reference the issue that is being solved, and keep referencing pull requests and issues back and forth

Working with Issues and PRs in GitHub
15:05
+ Working with an Open Source Project
6 lectures 01:10:11

This lecture is all about preparing your repository for people to start contributing to it. It is about protecting branches, setting the repo as public difectly from GitHub, and preparing one of the key files inside of any repo: the README.md file

Adding a README file
15:53

GitHub uses some templates in the form of markdown files to establish the content that will be generated by default when people create new pull requests and issues. This lecture is about creating the templates that will be used when reporting a bug, when requesting a new feature, and also about readying the file that prepares users for contributing

Adding the important Templates
16:10

In this lecture we will use some cool parameters of the git log command that will enable us to create some powerful and quick filters when exploring the commits that have been created in a certain repository. Filtering by author, date, and text in the commit message is covered in this lecture.

Filtering the Git Log to Better Understand the repo
09:17

In this lecture we are going to work through an entire contribution flow, now that the owner's repository has the templates in place and that we have forked the reository. This flow takes us through making changes to the code, commiting them to a feature branch, creating a pull request, and eventually syncing the original repository back with our fork.

The Full Contribution Flow - Beyond Pull Requests
14:43

This lecture we talk about the importance of feature branches, how you will be expected to use them, and even the naming conventions that you will likely be following.

Importance and Naming of Feature Branches
07:57

In this lecture we go through the importance of descriptive commits, comparing what it would be to experience a list of commit messages in a limited space like the terminal when the are not concise and descriptive, versus ones that are. Finally we offer 6 guidelines to creating the commit messages so that they are always easy to read and communicate the changes correctly.

Importance of Descriptive Commits
06:11
+ Markdown
7 lectures 01:07:25

In this lecture we will cover the places where markdown is supported, of course focusing on GitHub, but also outside of this context. We will also talk about some of the things that markdown can do such as text formatting, adding images, and working within issues, pull requests, comments and md files

Introduction to Markdown
06:55

In this lecture you will start to use markdown to create and edit an md file that displays the markdown text in a rich format. This lecture focuses on the basics of text formatting for setting bold, itallics, scratched, quotes and header texts.

Formatting Text with Markdown
10:48

In this lecture we are going to create ordered, unordered and checkbox lists and learn how is it that GitHub is going to display them and use them as metadata. We will take a look at the syntax needed by GitHub to correctly display sublists, and commit everything in a new branch.

Creating Lists with Markdown
10:59

In this lecture, following on the markdown practices, we will learn how to create tables inside of the md files or any markdown entry for that matter, along with how to create links to external sites. Also, we will learn how to align the content of a column in the tables using a simple syntax in the separating line, before commiting everything to a new branch, and creating a new pull request.

Adding Tables and Links with Markdown
10:12

In this lecture we will learn how to display images in our md files, comments, issues and pull requests using markdown in three different ways: using an image that is already on the internet, uploading it to our repository to access it locally, and ifnally uploading it to github user content.

Images and Videos using Markdown
13:54

In this lecture we are going to cover how to add code blocks to our markdown files and comments, as well as learn how is it that we can tell those blocks to format the code for a specific language.

Writing Code Blocks using Markdown
06:18

In this lecture I will present a tool that will help you create markdown files so you can easily design your md files and export them along with images for you to use them on GitHub.

The Notion App
08:19
+ GitHub Pages
3 lectures 19:58

In this lectire I will introduce GitHub pages as a tool that we can use to take our repositories and convert them into a website that helps us display the information that is inside them, whether that is HTML and CSS code, or Markdown. I also mention Jekyll, which will make our lives easier by providing awesome themes that can be applied to our pages.

Intro to GitHub Pages
06:23

In this lecture I will mention a couple of tims when creating the md (markdown) file that will eventually be usef by GitHub Pages as the content of your site, so that the visitors of your site can easily navigate between the projects that you will be shocasing.

Creating the Page's Content
07:20

Now that you have the markdown file ready in a new GitHub repository, in this lecture we will publish that repository as a GitHub page that uses the README.md file as the content, and integrates Jekyll in the form of a theme that makes the site look much better

Publishing a GitHub Page
06:15
+ Using Git and GitHub from the IDE
8 lectures 01:54:17

In this lecture I will mention the advantages and disatvantages of relying on the git integration that exist in different IDEs and cover hoe most of the time you still want to keep practicing how to use the terminal just so you are able to always execute any git command that you may need.

Intro to Git in Different IDEs
04:29

In this lecture we will explore how Android Studio uses git and GitHub for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository that can be created on GitHub directly from the IDE.

Git and GitHub in Android Studio
14:44

In this lecture we will explore how Xcode uses git and GitHub for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository that can be created on GitHub directly from the IDE.

Git and GitHub in Xcode
13:17

In this lecture we will explore how Visual Studio Code uses git for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository -that we created on GitHub- directly from the IDE.

Git and GitHub in Visual Studio Code
14:39

In this lecture we will explore how Visual Studio 2019 uses git and GitHub for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository that can be created on GitHub directly from the IDE.

Git and GitHub in Visual Studio
18:20

In this lecture we will explore how Visual Studio for Mac uses git for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository -that we created on GitHub- directly from the IDE.

Git and GitHub in VS for Mac
15:02

In this lecture we will explore how IntelliJ uses git and GitHub for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository that can be created on GitHub directly from the IDE.

Git and GitHub in IntelliJ
16:36

In this lecture we will explore how Eclipse uses git for version control by executing some commits, creating new branches, merging them, and pushing to a remote repository -that we created on GitHub- directly from the IDE.

Git and GitHub in Eclipse
17:10
Requirements
  • No prior programming knowledge required but such knowledge would be an asset.
  • No previous experience with Git or Github required.
  • A Computer running Windows, Mac OS or Linux.
Description

Git is the most used version control system for programmers in the world.  GitHub, with 57 million repositories (projects) and 28 million users is  the largest host of source code in the world.

The reality is, developers of all levels need to have a mastery of these tools. 

Why?

Firstly, because employers are demanding these skills.  Developers who don't know Git and GitHub have less opportunities available to them because so many companies are using one or both of these technologies.

Secondly, if you don't know how to use this technology you literally won't be able to function as a programmer anywhere that version control is used.  And thats most companies! Don't get left behind!

This course was designed to get you back in the race - by giving you a mastery of both Git and GitHub!

You will learn all the basics of Git and GitHub, everything from what a repository is, to adding your code to one.

Commits, Pull Requests, Forks, Cloning a repository, Branches, Handling Merge conflicts, Continuous Integration and Delivery, Markdown, GitHub Pages and Google Colab - It's all here.

But in addition to that you will learn how to use Git and GitHub in real life development situations, rather than learning theory only - So you will know how to use Git and GitHub the right way, and be ready to apply it to your professional development career.

Eduardo, your course instructor has structured this course in such a way that you will be able to follow the videos step by step and apply each concept as you go and finally build up to the final section on Continuous Integration / Continuous Delivery (a topic which is not covered by other Git and GitHub courses).

You truly will be a master of Git and GitHub by the end of the course.

I could go on and on about what's in the course, but all you really need to know is that this is a comprehensive course on the topic and Eduardo as the instructor, and Learn Programming Academy as the publisher have a great track record of producing high quality courses.    So you can be assured that its the right training you need to master Git and GitHub. This course is ready for you now.

Are you ready to start?  Click the Enroll button to get started.  Note that you can also check out some of the course content by using the free preview feature on this page.


Who this course is for:
  • Anyone who is willing and eager to learn more about Git and Github.