Best Git Courses

Find the best online Git Courses for you. The courses are sorted based on popularity and user ratings. We do not allow paid placements in any of our rankings. We also have a separate page listing only the Free Git Courses.

Git Started with GitHub

Learn the basics of Git and GitHub, with clear, step-by-step instructions by a highly rated teacher.

Created by Jason Taylor - Lead Software Engineer, Dev Trainer (19 courses,50k reviews)

"]

Students: 189961, Price: Free

Students: 189961, Price:  Free

This course is designed to jump right into showing how Git and GitHub work together, focusing on the Git basic workflow. Students can expect to learn the minimum needed to start using Git in about 30 minutes.

Recent Updates:

  • October 16th: Added Updates and Errata Section

Course Outline

Course Introduction and Overview provides an introduction to this course and the key concepts with the Git source control system.

Installation provides step-by-step instructions on how to setup Git for Windows and Mac OS X, how to use Git's help command.

After the Installation section, we walk through the entire Git basic workflow -- starting off in GitHub, working locally, and then publishing our changes back to GitHub.

Finally, I have some parting words and some bonus content!

Course Features

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.

Following each lecture or group of related lectures in the demo sections of the course are Command Listing lectures that serve as reference and reminder of the commands used in the previous lecture(s). Each Command Listing includes the exact listings used in the previous lectures and a reference guide for newly introduced commands. All commands used in this course are available through the Command Listing lectures.

Several attachments throughout the course provide supplemental information, illustrations, or other reference material.

Git from Basics to Advanced: Practical Guide for Developers

Learn Git from basics to advanced level. During the course we will create our own project that we will manage with Git

Created by Andrii Piatakha - Founder and CEO in IT-Bulls, Founder of Learn-IT University

"]

Students: 143061, Price: $59.99

Students: 143061, Price:  Paid

From this course you can learn Git from basics to advanced concepts.

This course created for software engineers who wants to learn how to track changes with the help of the Git. No matter what programming language you use - the git is equal for everyone :)

There are a lot of other courses in this topic. So, why would you choose exactly this course?  Here just a few reasons:

- Real-life cases & demo during the video lesson

There are a lot of other courses that teached you Git. But there are only power point presentations and nice digrams. You may learn hundrends of git commands but you won't be able to apply them in real life after that courses.

In this course we will imitate team work and work on the one project from scratch. We will review different life scenarios and online, on the video, I will show you the best way to approach varios cases.

You are going to learn enough theory to understand pracical examples and exercises. No watter :) Only Git!

- Practical orientation of the course

This is what makes this course so unique. During the course we are not talking about super abstract thing and inventing our own Git. Your focus is put on the questions that you will face with on daily basis during the software development. That's why this course is called 'Practical Guide for Developers'.

- Q&A support

The significant difference between online and offline learning process is instructor's availability. If you are in the one room with tutor he always can help you to get understanding specific concept or to help fix your code on your computer.
In this course, we are supporting students with answers to any questions flagged in Q&A section. In case there will be recurring questions - separate video lessons will be created to show how to address issue.

So with this course you are not just getting video materials, exercises, source code, access to fremote repository (which is still pretty cool, huh? :) ) , but you also get tutor support and answers to your questions along with this course.

- Relevant knowledge

After our team investigated other Git courses on Udemy we realized that most of them has nothing in common with real life and best practices in IT industry nowdays. Information which is shared there is very old and significantly out of date.

Instructor of this course is consultant in the top-rated IT outsourcing company and helps to bring cutting-edge solutions in IT for all his clients. Feel free to check LinkedIn page of instructor and check skills endorsement. More than 18 thousand people acrooss all over the world (BTW most of them are from top 100 companies of the world) evaluated skills of Andrii Piatakha.

With this course you can be sure that you will spend your time learning the right things from the one of the best IT consultants in the world.

- High concentration of useful material in each lesson

Sometimes you can notice that watching of 5 minutes of our lesson is equivalent to watching of other 30 minutes lesson.

This is because time spent for preparation for the lesson (script for the lesson, lesson structure) and video editing (to cut boring pieces of the lesson, or time when program loads) sometimes 10 times as much (sometimes even 20) as final lesson duration after video editing.

Also each topic is separated from another. In case some concept will be explained in the next lesson and you don't need to worry about understanding this in scope of this lesson - instructor will make announcement when specific topic will be covered.

Go and try it yourself! We will appreciate your feedback.

So don't wait! Take a look at lessons' preview if you still have doubts!

Buy this course today, and you will get all updates for FREE!

For those who successfully passed this training course, or for students who was recognized for asking amazing questions, there is a special offer from IT-Bulls company! The creator of this course is IT-Bulls company CEO and Founder. We always in search of talents to run our amazing startups together with you. Probably you always dreamed about running your own startup? In this course you will be able to find the team who will teach you how to do that and (in particular cases) will be glad to help with implementation!

Hope you enjoy this course! And remember, we appreciate all your feedbacks! Your feedbacks will help us to become even more better! Your feedbacks will help us to create to best Java course ever!

See you on the lessons! :)

Git & GitHub Crash Course: Create a Repository From Scratch!

Learn how to create a Git repository, clone it, make changes, and submit changes to GitHub in less than 30 minutes.

Created by Kalob Taulien - Web developer and coding instructor

"]

Students: 107123, Price: Free

Students: 107123, Price:  Free

Welcome to the 30 minute free Git and GitHub crash course! 

Employers and developers everywhere are using Git. This is why you should learn it (and also because it's powerful and a really cool tool!)

Git is a powerful (and VERY popular) versioning tool for web developers. But it's hard to get started because there's a lot to know and everyone assumes you already know the basics.

Looking for a short course on Git?
Looking for a short course on GitHub?
Then this is the course you're looking for!

This course is perfect for a web developers who's next step is to learn Git and GitHub. 

The core of this course is less than 30 minutes, and you'll learn:

  1. How to create a repository 

  2. How to copy it to your computer

  3. How to add files to your repository

  4. How to send the changes to GitHub

Plus you'll learn:

  • Git fundamentals, and

  • GitHub fundamentals

You'll also learn the terminology that developers use, like: cloning, staging, committing, pushing and diff. And you'll learn WHY Git is so popular and HOW it's powerful. And we'll be using GitHub which is the Git-service brand name.

Not sure if you should pay for an 8 hour course on Git? Take this course first to get your feet wet.

P.S. You'll learn how to do all this through your command line... because one day you'll be deploying code on a server and you'll need to use the command line, it's the only way! This course will set you up for success! ;) 

Git Complete: The definitive, step-by-step guide to Git

Go from zero to hero with Git source control step-by-step with easy to understand examples. Become the next Git expert!

Created by Jason Taylor - Lead Software Engineer, Dev Trainer (19 courses,50k reviews)

"]

Students: 87613, Price: $129.99

Students: 87613, Price:  Paid

Git Complete

This course is designed to be a comprehensive approach to Git, 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.

Recent Course Updates

  • Added Updates and Errata section
  • Added Tagging section

Course Outline

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, the first thing we do is Git Installation for both Windows and Mac.

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).

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. Finally, we cause trouble on purpose so we can step through resolving conflicting merges with our visual merge tool.

With a strong foundation in branching and merging, we will then cover a more complex topic, Rebasing. In that section, we cover several rebasing examples, including how to resolve a rebase conflict.

In the Stashing section, we save our work-in-progress while we attend to more pressing issues, then pick up where we left off after that.

NEW: In the Tagging section, we mark important milestones or releases within our project. We also use those tags later for comparing differences between important milestones. We also look at how to use tags within GitHub.

All tools have installation and configuration sections to ensure no one is left behind.

Course Features

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 nearly 4 hours of screencast based video training in order to step through each command or action in sufficient detail.

Several attachments and document lectures throughout the course provide supplemental information, illustrations, or other reference material.

Moving Forward

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 feature!

Command Line Essentials: Git Bash for Windows

A step-by-step guide for Windows users unfamiliar with Bash or the terminal environment.

Created by Jason Taylor - Lead Software Engineer, Dev Trainer (19 courses,50k reviews)

"]

Students: 85977, Price: Free

Students: 85977, Price:  Free

Command Line Essentials: Git Bash on Windows

This course is designed to cut academic theory to just the key concepts and focus on basics tasks in the Bash command line in order to be productive quickly. Students can expect to learn the minimum needed to start using the Bash shell in less than an hour.

Course Outline

Course Introduction and Overview provides an introduction to this course and the Bash shell environment.

Installation provides step-by-step instructions on how to setup Git for Windows and the Notepad++ text editor.

The real meat of the course is the Basic Commands section, where we step through many of the common Bash commands and uses. Towards the end, we start putting the commands together to build a simple Bash script, which we also execute.

Finally, I share some final thoughts in the Conclusion.

Course Features

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 -- this is the majority of the course.

Following the Basic Commands section, there is a downloadable reference of all the commands used in this course.

The quizzes reinforce the key concepts by testing your newly learned knowledge throughout the course.

Git Going Fast: One Hour Git Crash Course

Learn the key concepts and basic workflow for Git and GitHub with this easy to follow, top rated, bootcamp-style course!

Created by Jason Taylor - Lead Software Engineer, Dev Trainer (19 courses,50k reviews)

"]

Students: 77461, Price: $19.99

Students: 77461, Price:  Paid

Git Going Fast: One Hour Crash Course

This course is designed to cut academic theory to just the key concepts and focus on basics tasks in Git in order to be productive quickly. Students can expect to learn the minimum needed to start using Git in less than an hour.

Recent Course Updates

  • October 17th: Added Updates and Errata section

Course Outline

Course Introduction and Overview provides an introduction to this course and the Git source control system. Key concepts and the basic workflow are discussed.

Setup and Configuration provides step-by-step instructions on how to setup Git for Windows and Mac OS X, how to use Git's help command, and how to setup the minimum required configuration to start using Git.

In Working with Git Locally, we walk through all the 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.

Going Remote covers publishing the locally created repository (previous section) on GitHub. Starting off by setting up SSH authentication, creating the remote version of our repository, linking the local repository with the remote version on GitHub, and finally sending our changes up to remote repository.

Course Features

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 a total of 56 minutes of video based training in this course (Presentation + Screencasts, excluding Promo Video).

Following each lecture or group of related lectures in the demo sections of the course are Command Listing lectures that serve as reference and reminder of the commands used in the previous lecture(s). Each Command Listing includes the exact listings used in the previous lectures and a reference guide for newly introduced commands. All commands used in this course are available through the Command Listing lectures.

The four Quizzes reinforce the key concepts by testing your newly learned knowledge throughout the course.

Several attachments throughout the course provide supplemental information, illustrations, or other reference material.

Moving Forward

Students can checkout my last lecture on other Git related resources. The instructor is available for simple questions by email and can provide customized paid instruction upon request -- go the the author's profile for contact.

Git: Become an Expert in Git & GitHub in 4 Hours

Become an Expert in Git & GitHub by writing commands, learning theory, and taking quizzes. Learn Git today in 4 hours!

Created by VideoLab by Jad Khalili - Udemy Instructor - 80K+ Students Worldwide

"]

Students: 73172, Price: Free

Students: 73172, Price:  Free

Are you a developer looking to improve your workflow? Have you always wanted to learn source control? Are you looking to make your development workflow safer? Well, you have come to the right course.

Git is the industry-standard software for source control. With Git, you can save snapshots of your work as you go along in a timeline. Git allows you to create backups that take minimum space, making your work space safer. If you mess up, ruin your code, or damage your files, Git will be there to help.

In this course, we cover multiple aspects of Git & GitHub, including, but not limited to:

  • Git Theory & Workflow

  • Repositories & What they are

  • Basic Git Commands

  • Advanced Git Commands

  • A Complete coverage of GitHub & its features

  • Using Git & GitHub Together

  • Moving Git files to GitHub

And much, much more.....

We start from the complete beginning, talking about basic theory to familiarise new users with the environments we will be working in. Then, we introduce the Terminal, to make sure to alleviate any misconceptions about the Terminal, and to make sure you are comfortable with the environment before we move onto Git & GitHub. Remember, the main goal of the course is to teach Git & GitHub as smoothly as possible. 

Then, we move on to Git & GitHub. We break it up into step-by-step pieces, so that everything makes sense, and you fully understand each part before moving onto the next skill.

This is the only free course that takes Git, GitHub, version control, and basic Terminal knowledge, and bundles it together in one course for users of all levels. Whether you are a novice with no knowledge of the terminal, Git, or source control, or you are an established developer looking to integrate Git & GitHub into your work, this course has everything for you.

So, whether you are trying to learn Git for your work, or looking to learn for fun, this course will turn you into a Git & GitHub Master.

Git & GitHub For Beginners – Master Git and GitHub (2021)

Git & GitHub Masterclass for Beginners - Master Practical Key Concepts and Workflow of Git and Git Hub (Let's GIT IT!)

Created by Vlad Budnitski - System and Communication Engineer

"]

Students: 61213, Price: $89.99

Students: 61213, Price:  Paid

--> Ultimate Master Class for Git, GitHub, GitLab, and SVN <--

*** The Course Has been Optimized and now includes also Git and GitHub Premium Lectures ***

Ladies & Gentlemen!

--------------------------------- Introduction ---------------------------------

So you want to learn Version Control Systems.

Maybe that's Git, GitHub (or maybe both Git GitHub), GitLab, or even Bit Buckets. Doesn't really matter.

Let me teach you all the FUNDAMENTALS you need to get yourself STARTED as FAST as possible.

I know that your time is precious and maybe you're about to start a NEW JOB at your dream company or maybe you need to start working on your projects right away - so LET'S NOT WASTE TIME!

Studying our Git and GitHub Masterclass course will save you PLENTY of time googling and trying to connect the dots.

So WELCOME to my Ultra Practical & Summarized Git and GitHub Course to get yourself started! Let's Git It, shall we??

--------------------------------- Who is it for? ---------------------------------

Whether you want to improve your development skills, become a better programmer, or even increase your chances of getting your dream job.

You've come to the right place.

My name is Vlad and I’m talking about none other than my Version Control Systems (Git & GitHub) Ultimate Course where you're going to learn the basics of Git, its workflow, what is GitHub, and how Git and GitHub are connected.

So, if you’ve been using Python, C#, C++, or maybe you’re a Web Developer who’s using JavaScript, HTML, and CSS - what I can tell you, is this one thing - this course is definitely for you!

--------------------------------- About the Course ---------------------------------

Chapter 1 - Introduction to Version Control Systems (General - without Git / GitHub)

1. Common problems developers face (two main scenarios - without git, no version control, no collaboration)

2. What is a VCS in general (*and also what is Git, Git Hub, and even GitLab in particular)?

Chapter 2 - Learning Git Essentials

1. Git - Download & Install (covering "git version", "git help", "git help <command>")

2. Configuring basic git information (name+email).

3. Creating First Git Project (creating a project directory, "git init", "git status", talk about ".git" directory.

4. Basic Workflow of Git (creating new "hello_world" file, "tracked vs untracked", "3 stages", "git add", "git commit", "git log").

5. Basic Workflow of Git - Additional Practice (working with additional files in the project, modifying files, "git add .".

6. Reviewing Changes (diff "working directory" VS "last commit", "git diff").

7. Removing a file from git repository ("git ls-files", "git rm <file>", "git rm <file1> <file2>..., "git rm -r <dir>").

Chapter 3 - First Steps with GitHub

1. Why we need a Remote Version Control System (in general) and GitHub (in particular)?

2. Collaboration Importance.

3. What is GitHub and what does GitHub have to do with Git? Choosing RVCS!

Chapter 4 - Getting Started with GitHub

1. Creating a GitHub Account.

2. Configuring Remote GitHub Repository with Git.

Chapter 5 - GitHub (Commands & Functionalities)

1. Push Local Repository to GitHub.

2. Creating a New Repository on GitHub.

3. Clone, fork, and Pull - functionalities on GitHub.

4. Raw, Blame, and History - who to blame on GitHub :D.

5. Watch and Star.

6. GitHub Issues & Labels.

7. ".gitignore" - on both Git & GitHub.

8.  Git GitHub: Branch & Merge.

9. Conflict Resolution using Git and GitHub.

Chapter 6 - Version Control Premium Content: Visualization, Flow, and Commands

1. Introduction to Extended Visualization of the Git mechanism

2. Local Git Workflow Diagram

3. Untracked files in Git

4. Tracking New Files in Git

5. Staging Modified Files

6. Two States After Staged

7. Committing the Changes - as part of the Git Workflow

8. Skipping the Staging Area

Chapter 7 - Branching - Full Introduction To Merging

1. Branching - Real Life Scenarios [Intro To Merge]!

Chapter 8 - Merging - Process, Steps, and Merge Techniques

1. Merge - Fast Forward Technique (+Git example)

2. Merge - Recursive Merging 3-Way Merge

Chapter 9 - Conflicts Resolution

1. Merge Conflict - General Introduction

2. Merge Conflict Resolution - Core Part & Usage (solving conflicts in Git)

Chapter 10 - GitLab (Remote Distributed Version Control System) - Introduction

1. Creating GitLab Account

2. Create "MyFirstVehicle" Project on GitLab (remote git)

Chapter 11 - GitLab (Start Working)

1. SSH - Configuration & Clone

2. Create a new file & Push it to the remote git repository on GitLab

3. GitLab - Creating New Branches

4. GitLab - Merge Requests

Chapter 12 - SVN (SubVersion) - Centralized Version Control System

1. SVN - Introduction

2. SVN Workflow

3. SVN VS Git

4. Installation Preparation

Chapter 13 - Tortoise SVN - Down to Business

1. Tortoise SVN - Download & Install

2. Tortoise SVN - Creating a New Repository

3. Tortoise SVN - Hands On

4. SVN - File Differences

5. SVN - Branches

--------------------------------- Why Git & GitHub Version Control Systems Ultimate Course? ---------------------------------

Since I know many of you guys want to get to business right away - I’ve created this ultimate course with the most essential content you will need to feel confident with Git and GitHub and get yourself started as fast as possible.

You will get all the necessary explanations, straight to the point, without any irrelevant content - exactly what you need (including all the "git setup", etc).

And the last thing that I want to mention here - this course will be yours to keep as the Git and GitHub Cheat Sheet you can and should use whenever you will need it.

So I guess you know that this "Git and GitHub" course is ABSOLUTELY NECESSARY for you and that’s something you must have in your Developer ToolBox.

And without further ado, ENROLL in the course RIGHT NOW and I’ll see you inside.

* The content is mainly regarding "Git" and "GitHub", but ALSO you will get a few ADDITIONAL sections such as "GitLab" and "SVN". So much content to get yourself started! :)

Vlad,

The AlphaTech.

GitHub Ultimate: Master Git and GitHub – Beginner to Expert

Go from complete novice to expert in Git and GitHub using step-by-step, no-assumptions learning

Created by Jason Taylor - Lead Software Engineer, Dev Trainer (19 courses,50k reviews)

"]

Students: 45567, Price: $99.99

Students: 45567, Price:  Paid

This course will comprehensively cover the GitHub hosting service as a companion to the Git source control tool, which means no prior knowledge or experience is required. Students will emerge at the end with a very solid understanding and hands-on experience with Git and GitHub.

Course Organization

The course is divided into four major components:

  • Introduction and Setup

  • Learning Git Source Control

  • All About GitHub

  • Bonuses

Each one of the above components spans multiple sections in this course.

New! Video explaining how to resolve Git breaking when upgrading macOS each year

Introduction

The Introduction provides a welcome to the course including some useful tips for getting the most out of taking the course and how the course is designed. That is followed by the Core Concepts which go over some critical theory before diving straight into Git.

After the introduction and core concepts, the first thing we do is a Quick Installation for both Windows and Mac. The Bonus section has a more comprehensive, step-by-step process for those that prefer it.

Learning Git Source Control

In The Basics, 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 some more Advanced Git topics like comparing differences, branching and merge resolution, tagging special events, saving work in progress, and even a bit of time travel.

All About GitHub

The main part of this course is all about GitHub. We will explore GitHub indepth from a source control hosting repository perspective.

In Welcome to GitHub we start off exploring some of the basic features of GitHub by creating a fresh repository and associate our local repository with it. Then, we prepare for the remainder of the course by setting up SSH Authentication, which we will use from this point forward. After that, we continue looking at the GitHub Repository, including many of the same operations we performed locally, but done directly within GitHub. Then in GitHub Repository Branches we dive into how Branches on GitHub and our local system work with each other.

After we have comprehensively covered how GitHub repositories work, we focus on how GitHub Tags and Releases work and their relationship with local tags in Git. We can then use tags/releases while Comparing Differences on GitHub.

We start tying things together in Social Coding where we join other projects on GitHub by forking and then submitting our contributions back using pull requests.

Once part of a team, you might use GitHub Issues to track defects or enhancement requests.

Sometimes you just need to share small parts of a file or a set of files, but don't want to bother with a full Git repository. That where GitHub Gists help out -- share just a snip of code or entire files.

Finally, group related GitHub repositories with GitHub Organizations and manage permissions and access using teams.

Bonuses

The bonuses sections and lectures provide additional information, more comprehensive instructions, or non-critical lectures.

Course Features

All tools have installation and configuration sections to ensure no one is left behind.
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 nearly 5 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. 

Several attachments and document lectures throughout the course provide supplemental information, illustrations, or other reference material.

Moving Forward

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 feature!

Git a Web Developer Job: Mastering the Modern Workflow

Learn Git, GitHub, Node.js, NPM, Object-oriented JavaScript, ES6, webpack, Netlify, BEM and Job Interview Tips

Created by Brad Schiff - Web Developer

"]

Students: 32664, Price: $109.99

Students: 32664, Price:  Paid

This course was completely redesigned in November of 2019 to match the demands and trends of the industry.

You already understand the basics of HTML and CSS, but you don’t necessarily feel qualified for the web developer jobs you want. In this course we’ll bridge that gap by building a mobile-first responsive website, together, step-by-step. Along the way we’ll learn the modern skill-set that companies are looking for in developers.

I know what companies are looking for because as a senior developer I’ve been on the hiring side of job interviews. Every time we passed on a candidate I’d think to myself “It would be nice if we could point them towards a course that taught the exact skill set we’re looking for.”

I couldn’t find a course like that - so I built this one.

By the end of this course you’ll be able to build sites using the modern skills, tools, and best-practices that companies need in developers.

Take your developer career to the next level by:

  • Learning Git, GitHub, and command-line basics to collaborate with other developers and deploy your sites live up onto the web.

  • Leveraging Node.js tools like NPM and webpack to save time by automating tasks.

  • Enhancing your CSS knowledge with techniques (BEM & PostCSS) to keep your styles super-organized and manageable even on larger sites.

  • Speeding up your sites with the mobile-first performance philosophy.

  • Understanding JavaScript basics like Object-oriented Programming, and how to write well-structured code using the ES6 module pattern (Babel & webpack).

  • Using the Netlify service to not only host your website but also learn the very basics of cloud (or AWS Lambda) functions.

  • Discovering tips to get more job interviews, do well in interviews, and continually progress in your career (avoid burnout & stagnation).

This course may be brand new, but this isn’t my first time teaching. I’ve led trainings for Fortune 500 companies, and I’ve already helped over 7,000 people on Udemy and received the following feedback:

"Brad definitely has some of the best techniques to embed the lesson into your mind… hands down these are the best tutorials I have had the opportunity to view."

"Presentation is concise without being tedious… you honestly feel that you have a thorough understanding of the subject."

"…[Brad] explained the process. Not memorize this or that, he explained the process. If you're looking to take a course to understand the foundations of creating websites, look no further."

I've been teaching for the better part of a decade and I consider this course my magnum opus. This is the course I wish I could have taken several years ago.

Become highly valuable and relevant to the companies that are hiring web developers; in one convenient place alongside one instructor. If you're ready to begin your transformation - I'll see you on the inside!

Complete Git Guide: Understand and master Git and GitHub

Complete Git and GitHub guide (23 HOURS) - Master all Git features: commits, branches, merging, rebasing and squashing

Created by Bogdan Stashchuk - Software Engineer, CCIE #22608, MBA, PhD - stashchuk.com

"]

Students: 26515, Price: $109.99

Students: 26515, Price:  Paid

This course is all about Git and GitHub.

Understand HOW Git works and learn all Git features from basic commits to squashing and rebasing.

  • Blobs, Trees, Annotated tags, SHA1 hashes

If those terms are new to you - jump in and you will learn all about Git internals and afterwards practice basic and advanced Git features using multiple practice activities.

Become a master of Git, GitHub, GitHub Desktop, SourceTree and Visual Studio Code.

This is the most complete practical Git and GitHub guide here on Udemy that includes tons of practical activities. Most important is that you will learn how Git works and knowing it you will be able much more easier use Git features and fix mistakes in your development workflow. You can have zero knowledge about Git and GitHub. All will be taught from scratch, from basic to advanced features. If you want to get deep knowledge of Git and GitHub this course is for you!

We will start by exploring internal structure of the Git repository. You will learn that Git has 4 types of objects: blobs, trees, commits and annotated tags. Each object has unique SHA1 hash. Also all objects are stored in the folders. Every object has just single reference to it - SHA1 hash. Files are stored in blobs. Filenames are stored in other Git objects called trees.

I will explain you how to create new Git objects without using git commit and git add. After creating Git object in the Git repository you will checkout it to staging area and working directory (opposite direction to traditional Git flow)

Afterwards we will jump into tons of practice activities and use different Git and GitHub features

In practice sections you will perform multiple practice Git activities:

  1. Initialize new Git repository

  2. Make changes, add them to staging area and commit

  3. Create branches, checkout branches and merge branches

  4. Perform fast-forward and 3-way merges of the branches

  5. Resolve merge conflicts

  6. Move into detached HEAD state and make experimental commits there

  7. Perform rebasing of the branches

You will also learn and practice different GitHub features

  1. Connect local and remote repositories

  2. Pushing, fetching and pulling operations

  3. Open Pull Request

  4. Merge Pull Request

  5. Add software versions using Git Tags

  6. Create forks from other repositories

  7. Contribute to public repositories using technique of forks and pull requests

  8. Perform rebasing with squashing

You will use not just terminal and shell commands for performing Git operations. In parallel you will also use GUI applications that simplify routine day-by-day Git operations:

  • GitHub Desktop

  • SourceTree

  • VisualStudio Code

With this course you will get lifetime-long access to almost 200 lectures and tens of practical exercises. After the course you will become a guru of Git and GitHub and will be able easily perform basic and advanced Git tasks.

But most important is that you will UNDERSTAND Git.

You will also get 30-days money-back guarantee. No questions asked!

Don't wait and join the course now!

Learn Git: Everything You Need To Know

Git' started learning git today by learning all of the essential commands and tricks

Created by Adam Eubanks - Self Taught Programmer And Learning Enthusiast

"]

Students: 25703, Price: Free

Students: 25703, Price:  Free

Welcome to my fast-paced, focused git course.

  • Do you want to learn git?
  • Do you want to contribute to other people's projects on Github?
  • Do you want to share your projects with others?

If you answered yes to any of these questions, then this git course is perfect for you!

In this course, we will go through everything you need to know to use git and GitHub to manage your projects.

We will create a test project and go over everything from installing git, git branches to uploading to GitHub.

This course is incredibly fast paced (hence the smaller length). You will get up and running with git in minutes. Why waste your time listening to long lectures about things you will never use when you could instead take a shorter, more focused git course, and learn what you need to learn a lot quicker? This git course is unlike any other, you will learn what git commands you need to quickly. 

You will also learn how to integrate git with Github so that you can share your git projects with millions.

Git used to intimidate me. I did not want to memorize tons of git commands and I was scared I would mess up my projects. Luckily, I got over those challenges and created the perfect git course, that takes the fast learning approach that has made my other courses successful. If you feel like you are in the situation I was in, this course is for you.

In conclusion, if you want a focused, fast-paced course that will get you up and running with git and GitHub in minutes, then Learn Git: Everything You Need To Know is the course you've been looking for.


* If this course does not meet up to your expectations in any way, you can always claim your 30-day refund *

So what are you waiting for? You have nothing to risk!
Let's get started learning git!

Intro to Git

A fast and easy guide to version control

Created by Ian Schoonover - Full Stack Developer and Coding Instructor

"]

Students: 24700, Price: Free

Students: 24700, Price:  Free

What is this course about?
This course is designed to quickly teach you the fundamentals of git, so you can begin using it in your projects, today. Git is a popular and modern version control software that allows developers to track their code and collaborate with others. When tied in with GitHub, git becomes an even more powerful way to backup your projects and share them on the web.

What kind of materials are included?
The course is made up of video lectures and multiple choice quizzes. The only things you will need are a Cloud 9 account and a GitHub account (both are free). For those who are interested, instructions for installing git locally can be found at the end of the course.

How long will the course take to complete?
On average, it should only take a few hours to watch all of the videos, take the quizzes and implement the commands on your own. However, the pace at which you complete the course is up to you. 

How is the course structured?
The course is divided into a few short sections, each of which contains several video lectures. The video lectures are designed to tackle one or two new commands or concepts at a time, thus making the content easily digestible.

Why take this course?
A lot of the content from this course can be found online for free, but if you're the kind of person who learns better by seeing things in action, then this course is for you. The video lectures are designed to help you learn quickly, without the headache of reading through a lot of documentation. I also support your learning by being available to answer any questions you may have via the Q&A board. So what are you waiting for? Sign up now and get started learning git today! If you're unhappy with the course in any way then feel free to contact Udemy for their 30 day money back guarantee.

What students are saying:

"Ian covered all of the basic knowledge of Git functions and the purpose behind them. I now understand the basic concepts of Git and how I can apply them to my future projects via the command line interface. Short. Simple. Straight forward!"

"I'm learning a lot of new stuff easily."

"Concise and to the point. Well explained and great intro to git. Everything required to get started with Git is included in the course."

"The best introductory lessons for those [who] are new to github."

"Simple and easy to follow. Good information on understanding how Git works"

"Awesome! Easy to follow instruction!"

"Ian the instructor for the course explains clearly every step and what one should expect to happen. Very pleased with the course!"

"Easy to understand, and an awesome overview of Git. The branches make more sense now, thank you."

"This is a very well explained course for someone who has no clue about Git or GitHub. Enjoyed the course."

"Very good and easy to follow for beginners. Thanks to Ian again!"

Git and GitHub Crash Course

Learn basic Git features: commit changes, checkout commits and branches, merge branches, sync with GitHub

Created by Bogdan Stashchuk - Software Engineer, CCIE #22608, MBA, PhD - stashchuk.com

"]

Students: 24628, Price: $29.99

Students: 24628, Price:  Paid

This course is about basic features of the Git and GitHub.

Learn how to use Git and GitHub in about an HOUR!

  • Commits, branches, merging, GitHub and Git Objects

If those terms are new to you - jump in and you will learn what is Git and how to use its core features.

Become familiar with Git and GitHub to use it in your own projects and projects you potentially will contribute to in the future.

This is fast Git and GitHub Crash Course that will give you basic understanding of the Git and GitHub. Also using several practice activities you will practice core Git and GitHub feature like committing changes, pushing to the remote and merging branches.

We will start by installing Git and initializing new Git repository. You will learn that Git has 4 types of objects: blobs, trees, commits and annotated tags. Each object has unique SHA1 hash. Also all objects are stored in the folders. Every object has just single reference to it - SHA1 hash. Files are stored in blobs. Filenames are stored in other Git objects called trees.

You will learn how to make changes, stage them and commit afterwards. Also you will learn and practice how to observe commits tree and checkout different commits to "travel in time" between different states of the Git repository.

During this course you will practice all core Git and GitHub features

In practice sections you will perform multiple practice Git activities:

  1. Initialize new Git repository

  2. Configure Git author name and email

  3. Make changes in the working directory, add them to the staging area and commit

  4. Explore commits history

  5. Checkout different commits

  6. Create branches, checkout branches and merge branches

  7. Analyze contents of the Git objects

You will also learn and practice different GitHub features

  1. Create remote repository at GitHub

  2. Connect local and remote repositories

  3. Pushing and pulling operations

  4. Making changes in the files directly at GitHub

All Git operations you will perform in the Terminal - this is the best way to get started with Git to understand it better.

With this Git and GitHub Crash Course you will get lifetime-long access to around 20 lectures and multiple practical exercises. After the course you will become a confident user of the Git and GitHub and will be able easily perform basic Git tasks.

Don't wait and join the course now!

The Ultimate GIT 5-day Challenge

A quick way to determine if working with GIT is something you want to learn more about

Created by Brian Gorman - Software Engineer and Computer Science Instructor

"]

Students: 23097, Price: Free

Students: 23097, Price:  Free

This course takes us step-by-step through some basic GIT operations.  The course will not dive too deep, and takes small steps on each of five days.  As we continue through the course, we learn a basic, single-person workflow that could allow anyone to store files at GitHub or BitBucket.  

Additionally, the course gives us a chance to determine if we want to go to a deeper level with GIT.

DevOps MasterClass : GIT Docker Jenkins Kubernetes Terraform

DevOps for Absolute Beginners with Jenkins Docker Swarm Kubernetes GIT Terraform AWS with DevOps Realworld Exercises

Created by LevelUp360° DevOps - DevOps Professional Courses

"]

Students: 21705, Price: $109.99

Students: 21705, Price:  Paid

One of the Finest & Multi-Technology DevOps Certification Course On Udemy.

Celebrating #20000 Students, #20000 DevOps Certified Engineers with DevOps Specialization with DevOps Technology stack like Docker, Docker Containers, Docker Swarm, Kubernetes with Docker, Kubernetes Administration, Git & GitHub, Jenkins & Jenkins Code Pipeline, Terraform , Terraform AWS.

People are getting Pro in Jenkins, Docker, Docker Swarm, Terraform & Kubernetes and we are helping them to get more knowledge on DevOps Practices.

This DevOps Certification Training Course will prepare you for a career in DevOps, the fast-growing field that bridges the gap between software developers and operations.

The DevOps training course focuses heavily on the use of Docker containers, GIT & GitHub, Jenkins Kubernetes & Docker Swarm a technology that is revolutionizing the way apps are deployed in the cloud today and is a critical skillset to master in the cloud age.

This DevOps Certification Training Course will prepare you for a career in DevOps.

After completing this course, you will be able to:

1. Diagnose a team’s delivery pipeline and bring forward prioritized recommendations to improve it

2. Explain the skill sets and roles involved in DevOps and how they contribute toward a continuous delivery capability

3. Review and deliver automation tests across the development stack

4. Explain the key jobs of system operations and how today’s leading techniques and tools apply to them

5. Explain how high-functioning teams use DevOps and related methods to reach a continuous delivery capability

6. Facilitate prioritized, iterative team progress on improving a delivery pipeline

Course Objective?

This DevOps training is designed to help you become a DevOps practitioner. During this course, our expert DevOps instructors will help you: 

  • Understand the DevOps Ecosystem

  • Learn about automatic Source Code Management using GIT and Continuous Integration using Jenkins

  • Understand, Build and Test Automation: how to build an appropriate delivery pipeline and perform test automation on it

  • Understand Containerization using Docker: identify the difference between containers and VMs

  • Master Docker Commands and Use-cases: deals with the various networking concepts in Docker, the best way to use the Docker Volume, and creating Docker file

  • Master Puppet: learn Configuration management and "Infrastructure-as-Code". You can learn about the master-agent architecture and catalog compilation in Puppet

  • Learn Continuous Monitoring using Nagios: integrate Jenkins, Docker, and Puppet, and learn about system monitoring using Nagios and its components

  • Execute a live Project

Who should take this course?

DevOps career opportunities are thriving worldwide. DevOps was featured as one of the 11 best jobs in America for 2017, according to CBS News, and data from Payscale shows that DevOps Managers earn as much as $122,234 per year, with DevOps engineers making as much as $151,561. DevOps jobs are the third-highest tech role ranked by employer demand on Indeed but have the second-highest talent deficit.

This DevOps training course will be of benefit to the following professional roles:

  • Software Developers

  • Technical Project Managers

  • Architects

  • Operations Support

  • Deployment engineers

  • IT managers

  • Development managers

Prerequisite knowledge of software development, preferably in Java, and the UNIX/Linux command-line tools are essential for this course.

The Git & Github Bootcamp

Master the essentials and the tricky bits: rebasing, squashing, stashing, reflogs, blobs, trees, & more!

Created by Colt Steele - Developer and Bootcamp Instructor

"]

Students: 19779, Price: $89.99

Students: 19779, Price:  Paid

The following sentence is annoying, but also true: the best time to learn Git was yesterday. Fortunately, the second best time is today!  Git is an essential tool for work in any code-related field, from data science to game development to machine learning.  This course covers everything you need to know to start using Git and Github in the real-world today!

The course's 20+ sections are broken down into four separate units:

  • Git Essentials

  • Next Level Git

  • Github & Collaboration

  • The Tricky Bits

We start off with Git Essentials.  The goal of this unit is to give you all the essential Git tools you need for daily use.  We start off talking about version control software, what it is, why it matters, and the history of Git.  Then we install Git and run through the Unix commands you'll need to work with Git (you can skip this if you're already familiar).  The bulk of this unit is focused on teaching the core Git mechanics like committing and branching and the associated concepts: the working directory, the repository, the staging area, etc.    We cover Git commands including: git init, git add, git commit, git status, git log, git branch, and git merge.  We end with a detailed look at branching, merging, and resolving conflicts.

Then we move on to out Next Level Git unit, where we cover additional commands and Git concepts that are extremely useful, but maybe not as "core" as the Git Essentials.  We start with a comprehensive look at the gif diff command and the various comparisons that we can make between commits, branches, the working directory, the staging area, and more!  We pay special attention to reading and parsing the dense output generated by diffs.  Then we shift our focus to stashing with the git stash command, a "convenience command" that many users love incorporating into their Git workflow.  Finally, we dive deep into undoing changes and time traveling with Git.  We learn how to revisit earlier work, detach and re-attach HEAD, and discard changes.  We cover git commands that help us undo changes including git checkout, git restore, git reset, and git revert.

Next up, we change gears to focus on Github & Collaboration.  We start by exploring Github (and similar tools) that host remote repositories and discussing the benefits they provide.  We create our own Github repositories and sync up changes between our remote and local repositories using the git push, git pull, and git fetch commands.  We then focus on commonly used collaboration workflows that students may encounter in the real world: feature branching, pull requests, forking & cloning, and more! We discuss contributing to open source projects and configuring Github repositories for collaboration. We also spend some time learning about useful Github features including Github Gists and Github Pages for free static hosting.

The last unit in the course, The Tricky Bits, is really just a collection of useful Git command and advanced topics.  We start by covering one of the "scarier" Git commands: rebasing!  We discuss the potential benefits and pitfalls of rebasing and compare it to merging.  Then we learn how to clean up our Git history by rewording, editing, dropping, and squashing commits using the interactive rebase command.  Next, we discuss Git tags (lightweight and annotated tags) semantic versioning and tagging workflows.  After that, we move on to a deep dive into the inner workings of Git.  We discuss the files and folders Git uses internally, the role of hashing functions in Git, and the role of Git objects (blobs, trees, etc.). Next, we talk about reference logs and the git reflog command.  Specifically, we learn how we can use reflogs to rescue "lost" commits and undo rebases.  Finally, we learn how to write custom and powerful Git aliases!

Throughout the course, you'll find tons and tons of diagrams and visual references I've created to try and explain Git.  The course also includes exercises I've tested on my in-person students, to give you an opportunity to practice the concepts in the course along the way.  If you are reading this sentence, I congratulate you on making it this far :) I hope you enjoy the course!

Git Essentials: Learn Git with Bitbucket and Sourcetree

Git up to speed quickly with crucial technologies that will enhance your everyday workflow.

Created by Juke Jaster - iOS Developer & Designer

"]

Students: 18447, Price: $129.99

Students: 18447, Price:  Paid

Become apart of the Git train, it's mandatory if you want to work with any stable company, or even a start up company!

Note:

  • This course is not meant to be looked at as comprehensive on the topics of Git, Bitbucket, and Sourcetree.
  • This course is meant to be treated as an introduction to the topics of Git, Bitbucket, and Sourcetree. Once you complete the course, you will be able to dive deeper into the topics introduced.

Let me tell you a little bit about the course:

  • We start off the course by defining Version Control and Git.
  • We then go over the Git Glossary, which are the practical terms used for Git.

After we know the basics of git, we are going to practice it in the command line:

  • We will first install Git.
  • We will go over the basics of the command line like navigating through directories, etc.
  • Then we will practice git, and go through the process of executing git commands, anything and everything from staging, committing, viewing the history of commits, etc.

Once we feel comfortable with executing Git commands, we are going to be introduced to Sourcetree:

  • We will install Sourcetree.
  • We will mimic our example from the command line and do it in Sourcetree.
  • Once we have done things locally, we will move to Bitbucket.
  • We will learn everything from cloning a repository, all the way to pushing up local commits.

After all is finished there will be a challenge that I encourage you to attempt on your own. After your attempt, there is a solution video that will walk you through the challenge.

Git is mandatory if you want to be a developer, so it's not a matter of if you should learn it, it's a matter of when you should, and you should now!

Robot Framework : Code management(GIT) + Jenkins Integration

Git and GitHub introduction, Jenkins Setup on windows machine, Allure reporting

Created by Testing World Infotech - Working Professional, Having 9 Yrs of Experience

"]

Students: 16794, Price: Free

Students: 16794, Price:  Free

Git is the most widely used modern version control system in the world today, which allows multiple persons to safely work on the same project without hampering other team members. As a part of a team using Git, You and your team members will clone working copy of a local repository from Git server. You/team will add and commit the test scripts that are developed locally and push your changes to the Git.

This course gives coverage

1.  Execute Selenium test cases using Robot.

2.  Share code using Source Management tool GIT

3.  Integration Selenium with Jenkins using GIT.

4.  Execute automation framework using Jenkins

5.  Integrate Allure Reporting options

Git tutorials for Beginners – Complete Course

a complete practical course on git and github

Created by Kamal Girdher - Professional Trainer and Automation Expert

"]

Students: 15771, Price: Free

Students: 15771, Price:  Free

Far away from books, we have created this course to give you practical exposure of how git and github. You can easily follow our tutorials and become expert on git even if you have never worked on it.

In this course, you will not learn everything there is to know about  Git, but you will build a strong conceptual understanding of the  technology, and afterward will be able to confidently dig deeper on any  topic that interests you. This course assumes no previous knowledge of  Git, but if you do have experience with it, you may find this course to  be both useful and challenging. This is especially true if you currently  "know just enough Git to be dangerous".

Join us on Telegram for Questions/ Live Chat - t[dot]me/letsautomate

GIT for beginners

Learn version control system with Git. Do your everyday work simpler! Interview questions and Best practices.

Created by Maksym Rudnyi - Online Education from Senior Software Engineer

"]

Students: 13930, Price: Free

Students: 13930, Price:  Free

Why?

Are you front-end developer or back-end, in gaming or fintech development - doesn't matter. Version control system - is what unites us all. We work in teams and have to coordinate our work and code to deliver a high-quality solution.

How?

Git is the best tool to control your code. Learn concepts of Git to simplify your work!

Git & GitHub Complete Masterclass : Beginner to Git Expert

Most comprehensive, STEP by STEP Git & GitHub tutorial with great & easy to understand examples and Quizzes.

Created by Bibhash Roy - Developer, Architect, Spring, Devops Trainer & Entrepreneur

"]

Students: 13589, Price: $129.99

Students: 13589, Price:  Paid

Student are loving this course - here are few REVIEWS for this course:

"For the first time I managed to understand git and have it installed on my computer without any hustle. This must be the best git course on udemy hands down.The lecturers CLI has big texts which makes it easier to follow and always explains his steps. Please make more videos like this and take my money !" - Mr. Kelvin Mbewe

"This is an exceptional course, perhaps one of the best I've ever taken. The material is extremely well organized, and lessons are presented in a logical sequence. Bibhash is an enthusiastic instructor, and he has a very pleasant and engaging presentation style. I highly recommend this course. Thank you, Bibhash!" - Rebecca L. Lloyd

"The teacher has a very even pace and explains things thoroughly. He has a nice tone of voice - not to slow, not too fast. He explains git in a step-by-step manner that is easy to follow. He knows the topic well, and explains it well by leading you through examples in the terminal by telling how, what and why he is doing each step. I like learning about git from this guy. Everything is proceeding smoothly. Thank you Bibhash for teaching this course! I enjoy it a lot. Cheers!" - Jeff Jackson

"Excellent course. I will buy any course from this instructor simply for his effort in explaining the subject with so much passion. He covers the subject in depth. Visual tools to explain the concepts are very good." - sriram Subramani

"excellent course and instruction style! worth the money." - Josh Schmid

*****************************************************************************************************************************            

This course is aimed at providing rock solid foundation in Git. It covers the most needed basic and intermediate Git concepts that form the foundation of this wonderful source control management system (SCM) so that the student can go up and running within a matter of few hours. However, this is not say that this Git course covers things in hurry. On the contrary, all the foundation Git concepts are explained with utmost care so that the student feels (assuming a newbie or starter) comfortable with the concepts that has been laid down with great consideration and due diligence. The sections devoted to GitHub bears the same hallmark of care & clarity that the sections on Git are marked with.

The Git & GitHub course is power-packed with intensive hands on Lab sessions that covers the basic and elemental concepts in great detail. The Labs are the highlights of this Git course which implements all the concepts that are explained thoroughly and exhaustively in the presentations.

Course Layout

The section "Introduction and Getting Started" covers a great overview of Git that will warm up the student before taking on the concepts layered in the subsequent sections. To spice up things, it briefly covers history of Git. Next, the fundamental principles that govern Git is explained with well illustrated diagrams so that student doesn't face difficulty in facing the Labs that implements those concepts and principles. This section also introduces the Instructor and explains how to go through this Git course so that one get the best out of it.

The section "Git Setup and Installation" demonstrates the installation process of Git on all the three prevalent platforms, namely Windows / Linux / Mac. Each platform is covered nicely with detailed explanation so that student does not face any difficulty in understanding the Git setup process and one can get up and running without a hitch.

The section "Setting up a Git Repository" explains thoroughly the Git configuration process which forms the basic prerequisites before one goes to the next step of creating Git repositories. Once the prerequisites are taken care of, the subsequent lectures carefully crafts it way through explaining step-by-step process of Git repository creation process. The Git repository creation process comes in three flavors - creating from scratch with nothing on hand, converting an unversioned code base to Git repository and Cloning a Git repository that was existing on GitHub.

The section "Enter GitHub" explains this massively popular web based Git repository with utmost care and precision. It explains the hugely popular and effective GitHub "fork" and "clone" processes. Before that there are sections that navigate through GitHub in order to make the student familiar with GitHub website, it's user interface and general remote repository management process.

The section "Committing changes in Git" is where the action starts approaching the climax. Here the student will work on the Labs to in order to understand the few concepts that forms the pillars of Git, namely the "Git states". One can understand how an artifact (file / directory e.t.c) goes through the Git workflow to reach the climactic point wherein the artifacts are safely placed in the Git database.

The section "Inspecting what's going on in a Git Repository" explains how to peek into the internal workings of Git. In short - what's going behind the scenes! Git status and log checks are covered in great detail wherein students starts appreciating the beauty of Git.

The section "Git Branching basics" covers branching basic concepts. Branching is a advanced concept and attempt has been made not to burden the student with gory details of this advanced concept.

The section "Undoing changes in a Git repository" covers great details on the mechanisms you can use to undo changes in Git repository in case one changes his mind and want to revert changes or fix any mess up. Techniques such as resetting, reverting, cleaning and checkout for a Git repository have been treated with great care and detail.

The section "Pushing into GitHub" makes things hotter when the students starts learning how to extend one's arms beyond his local repository in local machine to a remote repository on GitHub. The local-remote interaction and play is fascinating as the lectures in this section unravels usage if Git and GitHub in step-by-step manner.

The section "GitHub via SSH" is an advanced one and hence had been kept for the last. Here you will learn how to connect with GitHub via SSH protocol. In the learning process, the student will learns basics of public key cryptography and it's implementation w.r.t GitHub. SSH key generation and using them to connect local Git repository and GitHub forms a stimulating walk in the entire learning path.

The section "Making Git bash friendlier and productive" will empower you to have Git bash prompt that allows customization in terms of it's content, color and functionality. It makes Git commands and their output highly readable and adds more expressiveness and color to all operations in the git bash terminal.

The section "Installing and Configuring default text editor for Git" demonstrates how to install a graphical text editor (Sublime Text) and configure it as the default text editor for Git.

The section "Installing and Configuring Diff and Merge tool for Git repository" demonstrates how to install and configure "p4merge" as Git diff and merge tool.

The section "Git Comparison with Git Diff Tool (p4merge)" demonstrates how to perform Git comparisons between various sections of a Git repository using "p4merge"

The section "Git Branching and Merging techniques" demonstrates advanced techniques for Git Branching and Merging that includes - fast-forward merge, no-fast-forward merge, 3-way merge along with merge conflict resolution process.

The section "Commit History rewriting in Git" demonstrates various technique for modifying commit history to suit your project needs. You can amend your commits, do a rebase and so on.

The section "Git Tagging" demonstrates how to use tags to mark production releases with tags and how to manipulate tags for best outcome

The section "Git Toolset" demonstrates git tool "stash" which is an extremely convenient tool to save off unfinished work.

On the final note in the section "Let's wrap up", the Instructor thanks the course taking students with some bonus tips!

Course Features

The course is heavily hands on with lots of great Lab sessions interspersed with brief slide presentations illustrating and unfurling the conceptual maze. All the commands that have been used in the relevant sections has been summarized in the form of text / pdf at the end of each section to consolidate the concepts that was laid down previously.

Udemy Money back guarantee!

If you enroll in this course, I guarantee you satisfaction of learning this hot technology with awesome lecture and Labs! However, there is nothing to loose, if you feel otherwise, since any Udemy course comes with 30 day money back guarantee! SO WHY WAIT! ENROLL IN THIS COURSE NOW!

Get Git Smart Course: Learn Git in Unity, SourceTree, GitHub

Use Version Control w/GIT, SourceTree & GitHub from Scratch in Unity Video Game Design (3.8 hours)

Created by Ben Tristem - GameDev.tv Founder :: Entrepreneur :: Passionate Teacher

"]

Students: 13218, Price: $89.99

Students: 13218, Price:  Paid

Want to learn Git without falling asleep? You're in the right place!

Learning version control can be tricky and boring, we're here to make it easy and fun. Using game development as the example project, we'll be showing step-by-step how to get into git (get it?).

By the end of the course you'll have an indispensable tool, that will allow you to...

  • Protect your valuable work using git version control.

  • Explore creative options using Atlassian's SourceTree & the terminal / command line.

  • Backup efficiently to the Internet, specifically GitHub but GitLab and BitBucket are mentioned.

  • Learn all the common version control workflows that you'll need day-to-day.

  • Lay the foundations for collaboration with others.

You won't only be learning the science of version control, but the art too. For example you'll learn common usage patterns that keep your live simple, and even how to setup your online portfolio to show your work in the best light.

Your instructor Ben Tristem is the founder of GameDev tv, and has taught 100,000s of students to code and use creative software from scratch, so you're in good hands. No prior experience of version control, git, or coding required.

We'll be covering Windows, however MacOS and Linux users can also follow along with a little modification.

Get plugged into our communities of amazing developers on Facebook (nearly 20k), in our own TA-curated Community (17k views/day), and our student chat group (10k live at any one time).

Let's dive in and get this mini super-power learnt in no time!

Free Hosted Website on GitPages and simple Git Guide

Explore how you can get started with GitHub create a hosted webpage from your repo and lots more

Created by Laurence Svekis - Instructor, GDE, Application Developer

"]

Students: 12140, Price: Free

Students: 12140, Price:  Free

Bonus free PDF guide packed full of resources and code snippets to help you learn - follow the lessons using the guide!  Learning made easy :)

Course is designed as a starter course to demo how to setup a free hosted website within gitPages

Covers basics of git and how it works

Tips and resources provided - including code editor that is used Brackets and how to start with simple git commands

Update your website locally and push it to your GitPages - made easy with easy to follow instructions and examples

Git command guide - simple git commands

Taught by an instructor with over 20 years of Web Development experience.

If you've been looking to get started with Git - wanted to refresh your git knowledge - learn the basics of git - or just want to see how you can get a free hosted website THIS COURSE IS FOR YOU!!!!

Nothing to lose - Fast friendly support is always available to help if you need it.

Please note that the SCOPE OF THIS COURSE IS BASICS of GIT and will not cover complex commands and everything about GIT its a simple HOW TO GET STARTED COURSE - if you are looking at more detailed git this is not for you.

Learn Git by Doing: A step-by-step guide to version control

Learn the basics of Git through detailed and easy to follow along screencasts. Start using Git today!

Created by Codingdojo, Inc. - Web Development Bootcamp

"]

Students: 12130, Price: $49.99

Students: 12130, Price:  Paid

Learn Git By Doing

This course is designed to get students working with Git and Github as soon as possible. By the end of the course students will have hands-on experience working with Git and Github and will be able to use Version Control on any project.

Course Principles

  1. Learn By Doing -- We believe that the best way to learn is by doing. That is why all of the core videos are designed for you to be able to follow along and reinforce the concepts taught in the video by actually typing along.

  2. 80/20 Rule -- With most technologies it takes 20% of the knowledge about the technology to be able to accomplish 80% of the tasks you need to do with that technology. Therefore it’s important to start by learning that crucial 20% that allows you to get up and running with the technology quickly. We still believe that you should learn the rest as well so we’ve included that material in the Advanced Topics section and continue to add to it.

  3. I do, We do, You do -- We believe that the best way to learn a new technology is to first observe how it is used, then code along with someone, and finally use the technology yourself. This is why we have our videos along with assignments throughout the course that allow you to solidify what you learned from following along.

Course Structure

The course is split into two main sections: Core Competencies and Advanced Topics.

Within the Core Competencies we first go over using the Terminal for students who have absolutely no experience with the Terminal (this section can easily be skipped by those who already feel comfortable interacting with the Terminal). We teach students how to navigate their folder structure and create files and folders. We then jump straight into Git and teach students how to create repositories and commit changes. We then teach students how to “go back in time” with resetting and reverting before moving on to branching and merging. After teaching the basics of Git we add in Github to show students how to interact with a remote repository and then we go over the proper workflow for collaborating using a remote repository.

After going through the Core Competencies we feel that the student will have a solid foundation to be able to use Git with collaborators on 80% of the tasks they may need to tackle.

In the Advanced Topics section we periodically add content on some more advanced aspects of git including Rebasing, Stashing, advanced Merge scenarios, etc. to make sure that students always have a place to learn the advanced concepts that they may not see too often but still need to know.

Sign up for the course and Learn Git Today!

Git with Visual Studio Code

An introduction to Version Control using Git, GitHub and Visual Studio Code

Created by Alex Horea - Web and Cloud Developer

"]

Students: 9672, Price: $19.99

Students: 9672, Price:  Paid

Do you want to get stared quickly to use Git, right inside your favorite IDE, Visual Studio Code?

Then you are at the right place!

Welcome to my Git with Visual Studio Code course, where you will learn everything you need in order to keep track of your awesome projects!

Here you will learn only what you need, no extra content, because time is precious!

Git & GitHub Masterclass

Add real world development team skills for version control and source control to your resume & programming arsenal!

Created by Tim Buchalka's Learn Programming Academy - Professional Programmers and Teachers - 1.24M students

"]

Students: 7475, Price: $79.99

Students: 7475, Price:  Paid

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.

Real-World Example: Git and GitHub on Windows – Basics

Learn How to use Git on Windows, Automate some common tasks and work with other People on GitHub

Created by Dan Georgiev - Programmer at Iris Technologies Ltd

"]

Students: 7403, Price: Free

Students: 7403, Price:  Free

Hi and Welcome to the Real-World Example: Git and GitHub on Windows - Basics Course.

My name is Daniel and I'm a Programmer and a small business owner.

In this course you will learn:

  • What is Git

  • How to install Git

  • The Command Prompt

  • How to use the Windows Command Prompt

  • How to use Git on Windows

  • The basic commands of Git

  • How to work with other people in GitHub

  • How to Automate some common Git tasks

Git for Geeks: Quick Git Training for Developers

Learn the core features of Git in less time for experienced software engineers new to Git

Created by Jason Taylor - Lead Software Engineer, Dev Trainer (19 courses,50k reviews)

"]

Students: 7207, Price: $49.99

Students: 7207, Price:  Paid

Git for Geeks

This course is designed to cut academic theory to just the key concepts and focus on basics tasks in Git in order to be productive quickly. Students can expect to learn the all the main features of Git in just two hours.

New! Closed captions throughout the course!

Course Outline

Course Introduction provides a welcome to this course with a few suggestions on how to get the most out of it. After that, we cover the minimum theory before getting our hands dirty with Git in the Core Concepts section.

Quick Installation provides an overview on the installation process for all tools needed for this course. A more detailed set of instructions are available in the Bonus section.

In The Basics, we walk through all the 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.

We then go a bit deeper in the Advanced section when we cover comparing changes, branching and merging (including merge conflict resolution), tagging milestones, saving temporary work, and even a bit of time travel.

Finally, Going Remote covers publishing the locally created repository (previous sections) on GitHub and BitBucket. We cover the main concepts related to working with any remote Git repositories and compare the differences between the two most popular Git hosting services.

After the main part of the course, this course offers several bonus sections that explore some topics in more detail for those that like more information.

Course Features

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. Excluding bonus lectures, this course offers about 2 hours of screencast videos.

Several attachments throughout the course provide supplemental information, illustrations, or other reference material.

Git & GitHub with Eclipse, Android studio & IntelliJ

Git and Github Bootcamp & Integration with popular development tools - Eclipse, Android studio & IntelliJ

Created by Bibhash Roy - Developer, Architect, Spring, Devops Trainer & Entrepreneur

"]

Students: 7172, Price: $124.99

Students: 7172, Price:  Paid

Student Reviews For The Git Bootcamp With GitHub Course.

"Brilliant course. Learned a lot and I am now using git and github in my software development. The videos and explanations are very clear and cover everything you need to get started using git and github." - David Crombie

"Not only does he teach the basics of git and GitHub, but he also shows how to use it with several different editors, and even shows you how to install all of them on top of it. I have a much better grip on git and GitHub and although I do need a lot of practice" - Francisca Roele

"The information on how to configure git and github was very clear and easy to follow. The examples on how to use git were easy to understand and the instructor showed how to use the most important features of git. Overall it is a very good introduction to the use of git and github." - Bill Coulter

======================================================

Maybe you've heard how version control is an important part of software development, but haven't gotten around to learn about Git yet?

Perhaps you have searched to find a course that will teach you the important parts of using Git and GitHub, but have failed to find one that actually explains things in detail, step by step.

Maybe you have an urgent need to understand how to use Git, but don’t want to spent hours watching videos that are fully of theory, but don’t include the necessary how-to information.

Or maybe you tried another Git course, and found that it was created by someone who is not a full time developer, and it left you needing more information.

If any of this resonates with you, then this is the course for you.

In this course, you will discover Git and version control systems in general, and obtain real world, value skills that can dramatically increase your career prospects as a software developer.

The fact is that an understanding of version control systems and source control in general is vital for developers in 2016, and this course will get you up to speed fast.

Git is one of those skills that employers look for on resumes, so don’t miss out on opportunities because you are do not have the necessary skills.

You will learn how to:

  • Setup and install Git for your operating system, with separate videos for Windows, Mac and Linux.
  • How to use Git from either the command line/shell, or from software development tools like IntelliJ, Android Studio, and Eclipse.
  • How to create and maintain your own Git repositories on your local computer.
  • Understand core Git commands like add, push, pull, checkout, clone, and more
  • Learn how to create new repositories on Github.
  • Obtain the skills to setup GitHub as a remote repository for your local Git repositories.
  • Learn how to download and install a valuable free tool that makes it dramatically easy to understand how Git works.
  • Understand the core differences between centralised version control systems and distributed version control systems, and why its vital to use the right system.
  • And for bonus points, find out the reason why Linus Torvalds, the inventor of Linux actually developed Git in the first place!
  • Plus lot’s more!

What about updates and support?

My other courses get continued updates and support, and this course is no exception.

We answer questions daily in the questions and answers area of the course, so you are never on your own.    

So, are you ready to get started? Enroll now and start your journey to understanding Git and Github today.