Short and Sweet: Next-Level Git and GitHub - Get Productive
4.6 (113 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,792 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Short and Sweet: Next-Level Git and GitHub - Get Productive to your Wishlist.

Add to Wishlist

Short and Sweet: Next-Level Git and GitHub - Get Productive

Save time, avoid pitfalls, and get productive fast. Learn Git collaboration, branching and merging in less than 2 hours!
4.6 (113 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,792 students enrolled
Created by Stephanie Losi
Last updated 1/2017
English
Current price: $10 Original price: $50 Discount: 80% off
3 days left at this price!
30-Day Money-Back Guarantee
Includes:
  • 2 hours on-demand video
  • 2 Articles
  • 6 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Know the basic Git and GitHub collaborative workflows
  • Learn how to collaborate using a Shared Repository model
  • Learn how to collaborate using a Fork and Pull model
  • Fix mistakes using 'git revert' and know when to use 'git rebase'
  • Full support from the instructor to get you started
  • Note: The course demonstrates Git use on a Mac, but resources are provided for Windows users, and if you run into snags, I'll do my best to help you
View Curriculum
Requirements
  • A GitHub account and Git command-line tools installed on your local computer
  • Familiarity with the basic Git command-line workflow to push commits to GitHub
  • A simple program uploaded to GitHub - this can be as simple as a "Hello, world!" program!
Description

*** Course Updated on January 9, 2016! NEW quiz! ***

Are you a software developer who uses Git and GitHub, or needs to start using these tools for work or a side project?

This 2-hour intermediate course takes away the guesswork. It builds on my free, introductory course Short and Sweet: Get Started with Git and GitHub Right Now, to tackle tough topics like collaboration, branching and merging. The intro course has 200+ reviews and 8000 students.

This course goes way beyond the intro course. More examples and more practical knowledge - and the same simple, no-nonsense structure.

Save time and get productive with Git and GitHub - fast!

In less than 2 hours, this Short and Sweet course will take you from beginner to intermediate skills, without a lot of filler. At the end of the course, you'll be able to add collaborators to your own projects, clone and collaborate on other people's or companies' projects, use branching and merging to minimize conflicts, fork projects, and recover from errors by rolling back to prior versions the right way.

That's a great trade for 2 hours of your time!

What do students say about this course?

“This is an excellent course on how to start using Git & GitHub with clear examples throughout the course. Gives all the good practises to start coding and committing code to your own or multi-user project. Shows you how to do all the usual commands and scenarios when developing code in a project.

“It also shows where & how things can go wrong and also VERY importantly shows what you must not do which could wreck other users’ submission of code or break the project.

“I would Highly Recommend this course as it covers the basics that you need to know. :-)” —Mark Collins

-----------------------------------------------------------------------------------------------

Why Git and GitHub?

Using Git on the command line can seem difficult because the commands are exacting, and they can trip you up if you get out of sync - but Git and GitHub are very powerful and absolutely essential for modern software developers.

That's because Git and GitHub are a mainstay of modern software version control. Used together, they provide a backup mechanism, a record of your project's history, a collaboration mechanism, and a base for a public portfolio that could get you a job.

"I truly enjoyed taking this course and I am happy to say that I am using some of the best practices listed in the course. I strongly recommend the course for newbies and even to people familiar with using git." —Darknight

-----------------------------------------------------------------------------------------------

Please note: This is a command-line-based course designed to get you productive FAST. This course assumes you already have a GitHub account, have installed Git on your computer, and have pushed your first commit. If you haven't, please enroll for free in my 30-minute introductory course Short and Sweet: Get Started with Git and GitHub Right Now.

But if you've already taken the introductory course, or you're slightly familiar with Git and GitHub and want to look under the hood and get serious, this course IS for you and I hope you'll enroll.

“I was already familiar with Git, but had not used it in a workflow that used pull requests. Also, I’ve been trying to understand the rebase command, and no previous explanation made sense to me. This course satisfactorily described both pull requests and the most-likely situation where I would use rebase.” —Steven Calwas

-----------------------------------------------------------------------------------------------

Second note (for serious students ONLY!): This course tackles collaborative Git and GitHub topics that many online courses and tutorials don't: It covers the Fork & Pull model (often used by larger, more established projects) and the Shared Repository model (often used by smaller or more informal projects).

Some of these topics are harder to study in an online course, because the best way to practice them is to have access as a collaborator to someone else's code repository. However, if you're new to Git and GitHub, you may not have that access.

Therefore, in this course, I encourage you to set up a secondary GitHub account and add your own primary account as a collaborator (don't worry, I'll show you how to do this!), so you can switch between accounts and practice collaboration that way. Is doing this a bit of a hassle? Yes. Is it the best way to learn the material in this course (at least, if you don't already have collaborator access)? Yes!

In fact, if you really want to go all the way and try everything, please be willing to switch between two user accounts on your computer, so you can use one account with your regular Git configuration and your regular GitHub account, and the second account with a different Git configuration and your secondary GitHub account.

Of course, you can always just watch the lectures and take notes, which should prepare you to collaborate on projects in the future with some base of knowledge.

But I encourage you to choose the active approach. I'm here to support the course, and if you put in the work and reach out when you have questions, I will put in the work to help you succeed.

-----------------------------------------------------------------------------------------------

2016 Updates

Update January 9, 2016: New end-of-course quiz!

-----------------------------------------------------------------------------------------------

How to Enroll

My goal is to make this course the best-ever guide to getting GOOD at Git and GitHub. Please let me know if anything in the course could be clearer, and I'll be happy to help you. It also will help me improve the course.

If you're ready to learn more and sign up for the course, go ahead and hit that Enroll button - you’ll gain:

  • Lifetime access to the course
  • Instant access to free updates that I make to the course over time.
  • Full support from me to address any questions you may have related to learning Git and GitHub.
  • AND, Udemy offers a 30-day refund guarantee, so there's no risk to you! Enroll now and let's get started!

Who is the target audience?
  • Anyone who wants to get productive fast using Git and GitHub
  • Anyone who wants to start contributing to other people's GitHub repositories
  • If you've never used Git and GitHub or aren't familiar with the basic workflow to push commits, this course is not for you - take a free introductory course first, please!
Students Who Viewed This Course Also Viewed
Curriculum For This Course
26 Lectures
02:06:09
+
Start Here - Introduction and Setup
3 Lectures 05:23

This lecture introduces the course and its prerequisites.

Preview 01:07

This lecture reviews the basic Git and GitHub workflow and answers the question: Are 'git add' and 'git commit' redundant?

Preview 01:50

This text lecture walks you through installing a credential helper, which will store your GitHub username and password and then automatically log you in whenever you push a commit. A downloadable PDF is also available.

Preview 02:26
+
Shared Repository: Collaborating When You Have Repository Access
10 Lectures 58:06

This lecture shows you how to add a collaborator to a GitHub repository that you own.

Preview 03:16

This lecture provides tips for studying this section of the course if you aren't already a collaborator on a real-world software project.

How to Study the Rest of This Section
2 pages

This lecture walks you through the first step in the Shared Repository collaboration model: cloning an exact copy of someone else's GitHub repository to your local computer. Support is available if you run into any problems.

Cloning Someone Else's Repository
04:47

This lecture shows you how to use the 'git pull' command to keep your local cloned repository up-to-date with its parent repository on GitHub.

Using 'git pull' to Stay Up-to-Date
05:34

This lecture introduces the idea of using branches for development work instead of making changes directly on the master branch.

Branching to Work on New Changes
05:43

This lecture walks you through creating a pull request, which asks the project owner to merge the changes in your new branch into the parent branch on GitHub. (The project owner can accept or reject the changes.)

Creating a Pull Request to Merge Your Branch
02:57

This lecture shows you how a project owner can merge changes from a pull request into the master branch. A second example gets you familiar with the entire workflow: branch --> pull request --> merge.

Practicing the Branch, Pull Request, and Merge Workflow
19:59

This downloadable PDF compares two basic Git and GitHub workflows: 1.) Pushing your first commit to your own Github repository; and 2.) Proposing your first change to someone else's GitHub repository if you are a collaborator (the Shared Repository model).

Comparison: Making Your First Commit vs Making Your First Collaborative Change
2 pages

This lecture explores the debate around the --no-ff option for the 'git merge' command - showing that Git workflows are not necessarily set in stone!

Preview 1 page

This lecture walks you through what a merge conflict is, how a merge conflict happens, and how to resolve it. This is one of the thorniest parts of using Git and GitHub!

Preview 15:50
+
Fork & Pull: Collaborating When You Don't Have Repository Access
4 Lectures 18:33

This lecture shows you how to fork someone else's GitHub repository, which is the first step in the Fork & Pull collaboration model. Fork & Pull allows you to propose changes even if you are not an official collaborator on the repository.

Forking Someone Else's GitHub Repository
04:15

This lecture walks you through cloning a forked GitHub repository and then making changes to it using a new branch.

Cloning and Branching with a Forked Project
08:47

This lecture shows you how to create a pull request from a forked repository on GitHub, asking the project owner of the original repository to review changes you propose.

Pull Requests for a Forked Project
05:31

This downloadable PDF compares the two collaborative Git and GitHub workflows: Shared Repository versus Fork & Pull.

Preview 3 pages
+
Mistakes, Reverting, Rebasing and Transferring Ownership
6 Lectures 32:21

This lecture acknowledges that mistakes happen - and then actively creates one, so we can fix it in the next lecture!

Handling Mistakes - When You Mess Up Your Git and GitHub Repos
06:19

This lecture walks you through using 'git revert' to return to a stable version after a mistake has been pushed to GitHub. The key reason to use 'git revert' is that it avoids rewriting the commit history.

Reverting a Commit
06:38

This lecture emphasizes why you should avoid rewriting published commit history at all costs - it's a major pain for other developers working on the project, and it goes against the entire philosophy of Git and GitHub.

Changing History - The Nuclear Option (Bad Idea!)
03:10

This lecture shows you how to use 'git rebase -i' locally to squash several small commits into one larger commit. Note that this is done before pushing the commits to GitHub. Once you push, don't rebase if at all possible.

Using 'git rebase' Locally and Squashing Commits
07:19

This lecture demonstrates how to use 'git stash' to store local changes for later if your work is interrupted before you're ready to commit.

Using 'git stash' to Store Changes for Later
05:43

As a project owner, you may want to transfer ownership of a repository to another user. This lecture shows you how to do it.

Transferring Ownership of a GitHub Repository
03:12
+
Wrap-Up and Next Steps
3 Lectures 02:00

This takeaway puts the best practices we discussed in this course at your fingertips. Note: Always adhere to your company's or organization's policies!

Git and GitHub Best Practices
2 pages

This lecture wraps up the core curriculum. After completing this course, you'll be able to do productive, collaborative work in Git and GitHub.

Wrap-Up and Conclusion
01:28

This quiz will help reinforce your learning during the course.

End-of-Course Quiz
14 questions

This lecture gives you next steps to continue learning about Git.

Bonus Lecture: What's Next and More from Stephanie Losi
00:32
About the Instructor
Stephanie Losi
4.3 Average rating
2,358 Reviews
35,401 Students
5 Courses
Tech Consultant and Trainer at 219 Labs, Inc.

Stephanie is a software developer, IT risk management expert and former journalist who loves learning. After several false starts, she taught herself to program in 2012 and wants to teach programming the way she wishes it had been explained to her. In addition to delivering online training courses through 219 Labs, her projects include developing a software tool that allows you to program in plain English. She has a master's degree in information security policy and management from Carnegie Mellon University, a bachelor's degree in journalism from Northwestern University, and attended Recurse Center (formerly Hacker School) in 2014. Her interests include organic food, art, travel and doing good work.