The ultimate beginner's guide to GitHub in 2025

Key Concepts

Git, Version Control, Working Directory, Staging Area (Index), Local Repository, Remote Repository, Branches, Pull Request, Merging, Git Configuration, Git Commands (init, status, add, commit, clone, checkout, switch, branch, push, pull, show), GitHub, GitHub Flow, Repositories, Licensing, .gitignore, Issues, Projects, Actions, Collaborators, Merge Conflicts.

Git and Version Control Fundamentals

• What is Git? Git is the most widely used version control system that tracks changes to files over time.
• Why use Version Control? Version control eliminates the need to save multiple versions of a file (e.g., "resume", "resume v2", "resume final") by tracking all changes within a single file.
• Working Directory: The workspace where you make changes to your files. Git hasn't been told to track these changes yet.
• Staging Area (Index): A draft space where you prepare changes before committing them, allowing you to review and adjust.
• Local Repository: The project's history stored on your computer, including all commits and branches.
• Remote Repository: A version of your project hosted on the internet or a network, enabling collaboration.
• Branches: Parallel versions of your project, allowing independent work on features or fixes.
• Pull Request: A proposal to merge changes from one branch to another, used for review and discussion.
• Merging: Integrating changes from one branch into another, creating a unified history.

Git Installation and Configuration

• macOS:
  • Install Homebrew using the command provided in the video.
  • Use Homebrew to install Git: brew install git.
  • Verify installation by running git in the terminal, which should display a list of available commands.
• Windows:
  • Download the latest version of Git for Windows from the provided link.
  • Follow the on-screen wizard prompts, accepting default settings.
  • Set the default branch name to "main".
  • Verify installation by running git in the terminal.
• Configuration:
  • Set username: git config --global user.name "your username".
  • Set email: git config --global user.email "your email address".
  • View configuration settings: git config --list.

Basic Git Commands

• Creating a New Folder: mkdir git-practice.
• Navigating into a Folder: cd git-practice.
• Creating a New File: touch hello.md.
• Initializing Git: git init (creates a new Git repository in the current folder).
• Checking Status: git status (shows changes, staged files, and untracked files).
• Adding Changes to Staging Area: git add . (adds all changes). git add [file name] (adds a specific file).
• Committing Changes: git commit -m "initial commit" (saves changes with a message).

Git Configuration and Aliases

• Git Config Command: Allows setting Git configuration values.
• Setting Username and Email:
  • git config --global user.name 'ladykerr'
  • git config --global user.email '[email protected]'
• Creating Aliases: git config --global alias.i init (creates an alias "i" for "git init").

Cloning a Remote Repository

• Git Clone Command: git clone [repository URL] (makes a copy of a remote repository to your local machine).
• Finding the Repository URL: On GitHub, click the green "Code" button, select "HTTPS", and copy the link.

Branching and Switching

• Creating a New Branch: git checkout -b update-name (creates a new branch named "update-name" and switches to it).
• Listing Branches: git branch (shows a list of all branches).
• Switching Branches: git switch main (switches to the "main" branch).

Pushing Changes to a Remote Repository

• Git Push Command: git push origin update-name (uploads changes from the local branch "update-name" to the remote repository "origin").
• Origin: Refers to the remote repository.

Pull Requests and Merging

• Pull Request: A proposal to merge changes from one branch into another.
• Creating a Pull Request on GitHub: After pushing a branch, a message appears on GitHub prompting you to open a pull request.
• Merging a Pull Request: Typically involves review by a coworker before merging.

Updating Local Repository

• Git Pull Command: git pull (fetches changes from the remote repository and merges them into the local branch).
• Importance of Git Pull: Keeps the local repository up to date with the remote repository.

Viewing Project History

• Git Show Command: git show (displays the changes made on the current branch, including commit ID, author, date, and content changes).

GitHub Flow

• Definition: A branch-based workflow for collaboration.
• Steps:
  1. Clone the repository.
  2. Create a new branch.
  3. Make changes on the branch.
  4. Push the branch to GitHub.
  5. Open a pull request.
  6. Request feedback and address comments.
  7. Merge the pull request into the main branch.
  8. Delete the branch (locally and remotely).
• Deleting a Branch Locally: git branch -d update-name.
• Deleting a Branch Remotely: git push -delete origin update-name.

GitHub Repositories

• Definition: A space where project files live, allowing for version control and collaboration.
• Creating a Repository:
  1. Click the green "New repository" button.
  2. Enter a repository name.
  3. Add a description.
  4. Choose public or private visibility.
  5. Initialize with a README file.
  6. Select a license.
  7. Click "Create repository".

Licensing

• Definition: Tells others what they can and can't do with your source code.
• Open Source: Sharing code with others under a specific license.
• MIT License: A permissive license that allows anyone to use your code for almost anything, as long as they keep the license file intact.
• Resource: choosealicense.com for learning about different licenses.

Forking

• Definition: Creating a copy of a repository to your own system to make changes.

.gitignore File

• Purpose: Specifies files or file types that Git should ignore and not track.
• Example: Excluding .DS_Store files on macOS.
• Resource: gitignore.io for creating .gitignore templates.

GitHub Repository Features

• Issues: Track bugs or tasks.
• Projects: Organize tasks in a Kanban-style board.
• Pull Requests: Merge changes from different branches or forks.
• Wikis: Documentation and FAQs.
• Settings:
  • Manage collaborators and access.
  • Set up automation with GitHub Actions.
  • Configure security settings.
  • Enable or disable repository features.

Adding Code to a Repository (GitHub Flow)

• Cloning the Repository: git clone [repository URL].
• Creating a New Branch: git checkout -b version1.
• Adding Files: touch index.html script.js.
• Staging Changes: git add ..
• Committing Changes: git commit -m 'created initial project'.
• Pushing to Remote Repository: git push origin version1.
• Opening a Pull Request: Click the "Compare & pull request" button on GitHub.
• Pulling Remote Changes: git switch main, then git pull.
• Merging Main into Branch: git switch version1, then git merge main.

Uploading Files to GitHub

• Using GitHub UI:
  1. Create a new repository.
  2. Click the "plus" button and select "Upload files".
  3. Choose files to upload.
  4. Add a commit message and commit changes.
• Using Git Commands:
  1. cd into the project folder.
  2. git init.
  3. touch README.md (add a description to the file).
  4. git add ..
  5. git commit -m 'initial commit'.
  6. git branch -M main.
  7. git remote add origin [repository URL].
  8. git push -u origin main.

Creating a Pull Request

• Steps:
  1. Clone the repository.
  2. Create a new branch: git checkout -b update-name.
  3. Make changes in the editor.
  4. Stage and commit changes: git add ., git commit -m 'update game name'.
  5. Push changes to GitHub: git push origin update-name.
  6. Click the "Compare & pull request" button on GitHub.
  7. Add a title and description.
  8. Create the pull request.
• Best Practices:
  • Write small PRs.
  • Review your own PRs first.
  • Provide context and guidance in titles and descriptions.

Resolving Merge Conflicts

• Definition: Occurs when changes are made to the same part of the same file on two different branches.
• Resolving in Terminal:
  1. git switch main.
  2. git pull origin main.
  3. git switch update-name.
  4. git merge main.
  5. Accept the desired changes in the conflicted file.
  6. git add ..
  7. git commit -m 'resolve merge conflict'.
  8. git push origin update-name.

Conclusion

This video provides a comprehensive guide to getting started with Git and GitHub, covering essential concepts, installation, configuration, basic commands, branching, pull requests, and resolving merge conflicts. It also introduces the GitHub Flow and best practices for collaboration. The video emphasizes the importance of understanding these tools for effective version control and teamwork in software development.