Introduction to Git and GitHub: A Beginner's Guide to Version Control

This chapter provides a foundational understanding of Git and GitHub, essential tools for modern software development and collaborative projects. We will explore the core concepts of version control, the functionalities of Git and GitHub, and their combined benefits for developers and teams. This material is adapted from an introductory video designed to help beginners grasp the fundamentals of these powerful tools.

1. Understanding the “What and Why” of Git and GitHub

Git and GitHub are often discussed together, but it’s crucial to understand that they are distinct yet interconnected tools. Let’s break down each one:

1.1 What is Git?

Git is a version control system (VCS).

A version control system is a software tool that tracks changes to files over time. It allows you to revert to previous versions, compare changes, see who modified what and when, and collaborate more effectively with others.

At its core, Git is designed to manage and track changes in your source code.

Source code refers to the human-readable instructions that make up a software program. It is typically written in languages like Python, Java, JavaScript, or HTML.

Think of Git as a sophisticated system that keeps snapshots of your project at different stages. This allows you to:

• Save different versions of your code: Git records the history of your project, enabling you to access any previous state.
• Track changes over time: You can easily see what modifications were made, when they were made, and by whom.
• Revert to earlier versions: If you make a mistake or want to revisit a previous feature, you can effortlessly jump back to an older version of your code.

Git operates primarily as a local tool.

A local development environment refers to the setup on your personal computer where you write, test, and manage your code.

It’s free to download and use on your computer, making it ideal for individual projects and local development.

1.2 What is GitHub?

While Git is a local version control system, GitHub extends its capabilities into the realm of online collaboration and hosting. GitHub is a hosting and collaboration provider specifically designed for Git repositories.

A hosting provider is a company that offers services and infrastructure to store and manage data and applications online.

A collaboration provider facilitates teamwork and shared access to resources, enabling multiple individuals to work together on a project.

A Git repository is a folder or project that is being tracked by Git. It contains all the project files and the history of changes managed by Git.

GitHub provides a platform to:

• Host Git repositories in the cloud: It allows you to upload your local Git projects to a remote server, making them accessible online.
• Enable team collaboration: GitHub facilitates teamwork by providing tools for managing access, reviewing code changes, and coordinating contributions from multiple developers.
• Enhance project accessibility: By hosting projects in the cloud environment,

A cloud environment refers to a network of remote servers hosted on the internet that are used to store, manage, and process data, rather than using a local server or a personal computer directly.

GitHub makes them accessible from anywhere with an internet connection, and by multiple collaborators.

• Serve as a server-based solution:

A server-based solution is a system where data and applications are stored and processed on a central server, rather than on individual client devices.

GitHub acts as a central server for your Git repositories, streamlining collaboration and project management.

1.3 Why Use Git and GitHub?

To understand the “why,” let’s consider common scenarios developers face:

• Managing Multiple Drafts: Imagine writing an essay or working on a text document. Without version control, you might create multiple copies (e.g., “essay_draft1,” “essay_draft2,” “essay_final”). This approach is disorganized and inefficient.
• Avoiding Data Loss: Alternatively, you might work on a single file, constantly overwriting previous versions. This risks losing earlier progress or valuable sections you might want to revisit.

Version control systems like Git offer a superior solution. With Git:

• Single File Approach with History: You work within a single project folder, but Git maintains a complete history of all changes.
• Easy Reversion: You can easily “check out” (retrieve) any previous version or “draft” without creating multiple copies.
• Clean Project Structure: Your project folder remains clean and organized, containing only the current version of your files.

Beyond basic version management, Git and GitHub offer numerous advantages, especially for developers:

• Collaboration: Essential for team projects, enabling multiple developers to work on the same codebase simultaneously without conflicts.
• Feature Branching: Allows developers to work on new features or bug fixes in isolation, without disrupting the main project.
• Code Review: GitHub provides tools for reviewing code changes before they are integrated, improving code quality.
• Issue Tracking: GitHub offers issue tracking systems to manage bugs, feature requests, and tasks related to the project.
• Project Hosting and Sharing: GitHub serves as a central hub for hosting and sharing code, facilitating open-source contributions and project visibility.

While primarily designed for developers, Git’s version control capabilities can theoretically be applied to various file types, even documents like Word files. However, its strengths are most pronounced in managing code and facilitating software development workflows.

2. Course Overview: Learning Path and Key Modules

This course is structured to guide you from Git and GitHub beginners to proficient users. It covers essential concepts and practical skills through a series of modules:

• Optional: Mac Terminal and Windows Command Prompt Basics: This module provides a refresher on using the command line interface on both macOS (Terminal) and Windows (Command Prompt).

  The command line is a text-based interface for interacting with a computer’s operating system. Users type commands to instruct the computer to perform specific tasks, in contrast to using a graphical user interface (GUI) with a mouse and icons.

  Understanding the command line is crucial for working with Git, as Git commands are primarily executed through this interface. This module is optional for those already comfortable with these tools.

• Git Basics: This core module introduces fundamental Git concepts and commands:

  • Installation: Setting up Git on your local machine.

  • Core Concepts: Understanding the working directory, staging area (or index), and repository.

    The working directory is the folder on your computer where your project files are located and where you make changes to your code. It’s the area where you directly interact with your project’s files.

    The staging area, also known as the index, is an intermediate area where you prepare changes from your working directory to be included in the next commit. It acts as a buffer between your working directory and the Git repository.

    The repository in Git, often referred to as the Git repository, is a hidden folder (typically named .git) within your project directory that stores the entire history of changes, commits, branches, and other metadata related to your version-controlled project. It’s the database where Git keeps track of all versions of your files.

  • Commits: Learning how to create commits to save snapshots of your project’s state.

    A commit in Git is a snapshot of your project at a specific point in time. It represents a saved version of your changes and includes metadata such as a commit message, author, and timestamp. Commits form the history of your project in Git.

  • Branches: Understanding and working with branches to manage parallel development and features.

    A branch in Git is a parallel version of your repository. It allows you to diverge from the main line of development and work on new features or bug fixes without affecting the stability of the main project. Branches are essential for collaborative development and feature isolation in Git.

  • Basic Branch Operations: Creating, deleting, and switching between branches.

• Git Deep Dive: This module explores more advanced Git concepts and commands for deeper understanding and control:

  • Git Stash and Reflog: Tools for managing temporary changes and recovering lost commits.
  • Branch Combination: Techniques for integrating changes from different branches, including:
    • Git Merge: Combining branches to integrate changes.
    • Git Rebase: Another method for integrating changes, often used to maintain a cleaner commit history.
    • Cherry Picking: Selecting specific commits from one branch to apply to another.

• GitHub Integration: This module bridges the gap between local Git projects and the cloud with GitHub:

  • Remote Repositories: Understanding how to work with remote repositories hosted on GitHub.
  • Remote Branches: Managing branches on remote repositories.
  • Remote Tracking Branches and Local Tracking Branches: Concepts related to synchronizing local and remote branches.
  • Essential GitHub Commands:
    • Git Clone: Downloading a remote repository to your local machine.
    • Git Push: Uploading local commits to a remote repository.
    • Git Pull: Downloading changes from a remote repository to your local machine.
    • Git Fetch: Retrieving changes from a remote repository without automatically merging them.

By completing these modules, you will gain a comprehensive understanding of Git and GitHub, equipping you to effectively manage your projects and collaborate with others in a version-controlled environment.

3. Git Basics: Core Concepts in Detail

Let’s delve deeper into the fundamental concepts of Git and how it manages version control. We’ll use a simplified example of a webshop project to illustrate these concepts.

3.1 Working Directory and Initial Project State

Imagine you have a project folder named “webshop.” Initially, it might contain files like:

• index.html (structure of the webpage)
• style.css (styling of the webpage)
• images/ (folder containing images)

At this stage, your project is simply a folder with files on your computer. Git is not yet involved.

3.2 Turning a Project into a Working Directory

To bring Git into the picture, you need to initialize Git within your project folder. This transforms your project folder into a working directory managed by Git. This is typically done using the git init command (which we will explore later).

3.3 Commits: Saving Project Snapshots

Once Git is initialized, you can start saving snapshots of your project’s state. These snapshots are called commits. Think of a commit as a saved draft of your project at a particular moment.

Example Scenario:

1. Initial Commit: You create your initial project structure (index.html, style.css, images/) and create your first commit. This commit represents the first version of your webshop project.
2. Second Commit (Style Changes): You then work on style.css, making changes to the website’s appearance. You create a second commit. Git intelligently tracks only the changes made to style.css since the first commit, rather than saving the entire project again. This is efficient in terms of storage and tracking changes.
3. Third Commit (Adding JavaScript): You add a new file, script.js (a JavaScript file for website interactivity). You create a third commit. Git records the addition of this new file and any changes in relation to the previous state.

3.4 Branches: Managing Parallel Development

Internally, Git organizes commits within branches. The master branch (now often referred to as main branch) is the default primary branch in a Git repository. It’s often considered the main line of development or the “production-ready” version of your project.

Branching for Feature Development:

Branches become powerful when you want to work on new features or experiment without directly altering the main project (master branch).

Example: Landing Page Feature

1. Creating a Branch: You decide to work on a new landing page for your webshop. You create a new branch called “landing-page” (or similar). This branch is essentially a copy of your master branch at the point of creation.
2. Working on the Branch: You switch to the “landing-page” branch and make changes specifically for the landing page (e.g., add new files, modify existing ones). These changes and subsequent commits are isolated within the “landing-page” branch and do not affect the master branch.
3. Merging Back to Master: Once the landing page feature is complete and tested on the “landing-page” branch, you can merge the “landing-page” branch back into the master branch. This integrates the changes from the feature branch into the main project.

3.5 Git Repository: The Engine Behind Version Control

To understand how Git manages all this versioning, we need to look at the Git repository. When you initialize Git in your project (using git init), Git creates a hidden folder named .git within your project directory. This .git folder is the Git repository.

The repository contains two key areas:

• Staging Area (Index): This is a temporary holding area. When you make changes to files in your working directory, you first stage these changes (using git add) to indicate that they should be included in the next commit. The staging area is like a draft area where you prepare your changes before making them permanent in the repository’s history.
• Commits (Objects Folder): The repository stores all the commits (snapshots) of your project in an efficient manner. Critically, Git doesn’t save entire file copies with each commit. Instead, it intelligently tracks and stores only the changes (differences) between commits. This minimizes storage space and makes version history efficient.

Workflow Summary:

1. Working Directory: You make changes to files in your project folder (working directory).
2. Staging Area: You use git add to stage the changes you want to include in your next commit.
3. Repository (Commits): You use git commit to create a new commit (snapshot) from the staged changes. Git stores these commits and their history in the .git repository.

4. Setting Up Your Development Environment: Installation of Git and Visual Studio Code

To start working with Git practically, you need to install Git on your computer and ideally have a code editor or Integrated Development Environment (IDE).

An IDE (Integrated Development Environment) is a software application that provides comprehensive facilities to computer programmers for software development. An IDE normally consists of at least a source code editor, build automation tools, and a debugger.

4.1 Git Installation

1. Download Git: Visit the official Git website (https://git-scm.com/) and download the appropriate installer for your operating system (Windows or macOS).

2. Run the Installer: Execute the downloaded installer file.

3. Installation Options: During installation, you’ll be presented with various options. For most options, the default settings are sufficient for beginners. Pay attention to these points:

   • Windows Explorer Integration: You can untick this option as it’s not essential for this course.
   • Adjusting your PATH environment: Ensure “Git from the command line and also from 3rd-party software” is selected (the recommended option).
   • Choosing the SSH executable: “Use bundled OpenSSL library” is generally fine.
   • Configuring line ending conversions: Select “Checkout Windows-style, commit Unix-style line endings” for cross-platform compatibility, especially if collaborating with users on different operating systems (Windows and macOS).
   • Choosing the terminal emulator to use with Git Bash: Select “Use Windows’ default console window” to align with the course’s use of the Command Prompt.
   • Configuring extra options: Enable file system caching (default is fine).

4. Verify Installation: After installation, open the Command Prompt (on Windows) or Terminal (on macOS). Type the command git --version and press Enter. If Git is installed correctly, you should see the installed Git version number displayed.

4.2 Installing Visual Studio Code (VS Code)

While you can use any text editor, Visual Studio Code (VS Code) is a highly recommended, free, and cross-platform IDE that is well-suited for Git-based development.

1. Download VS Code: Go to the VS Code website (https://code.visualstudio.com/) and download the installer for your operating system.

2. Run the Installer: Execute the downloaded installer file.

3. Installation Options:

   • Accept the license agreement.
   • Choose the installation location (default is usually fine).
   • On the “Select Additional Tasks” page, ensure “Add to PATH” is checked. This allows you to use VS Code commands from the command line.

4. Launch VS Code: After installation, launch Visual Studio Code.

5. Integrated Terminal: VS Code has an integrated terminal,

   In software development, a terminal (also known as a command prompt or shell) is a text-based interface that allows users to interact with the operating system and execute commands. It provides a way to control the computer by typing commands, rather than using a graphical user interface (GUI).

   which is very convenient for working with Git. To use the Command Prompt in VS Code (on Windows):

   • Go to “View” > “Appearance” > “Panel” to show the panel (terminal area).
   • Click the dropdown arrow in the panel and select “Select Default Shell.”
   • Choose “Command Prompt” and confirm.
   • You can remove other shells (like PowerShell) by clicking the “Remove” icon if you want to keep only the Command Prompt.

6. Open Your Project Folder: In VS Code, go to “File” > “Open Folder” and navigate to your project folder (e.g., “git-basics” or “initial-project”) and select it. Your project files will now be visible in VS Code’s Explorer pane.

With Git and VS Code installed and set up, you are now ready to start using Git commands to manage your projects.

5. Basic Git Workflow: Initializing, Staging, Committing, Branching, and Merging

Let’s walk through a basic Git workflow using commands in the Command Prompt within VS Code.

5.1 Initializing a Git Repository (git init)

1. Navigate to Your Project Folder: Open the Command Prompt within VS Code (or your system’s command prompt) and use the cd command to navigate to your project folder (e.g., cd Desktop\git-basics).
2. Initialize Git: Type the command git init and press Enter. This command initializes a new Git repository in your current folder. You’ll see a confirmation message indicating that an empty Git repository has been initialized. A hidden .git folder will be created in your project directory.

5.2 Checking Git Status (git status)

1. Check Status: Type git status and press Enter. This command provides information about the current state of your working directory and staging area.

   • Initially, after git init, git status might show “No commits yet” and “Untracked files.” Untracked files are files in your working directory that Git is not yet aware of.

     Untracked files in Git are files in your working directory that Git is not currently monitoring or including in version control. These are typically new files that have been added to the project folder but haven’t been explicitly added to the staging area using git add.

5.3 Staging Files (git add)

1. Create a File: Create a new text file within your project folder (e.g., initial-commit.txt) using VS Code or any text editor. Add some text to the file and save it.

2. Stage the File: Use the git add command to stage the file.

   • To stage a specific file: git add initial-commit.txt
   • To stage all changes in the current directory: git add . (the dot represents the current directory)

3. Check Status Again: Run git status again. You should now see “Changes to be committed” and your newly added file listed under “New file.” This indicates that the file is now in the staging area and ready to be committed.

   Changes to be committed in Git refers to modifications in your staging area that are ready to be saved as a new commit in your repository’s history. These changes have been explicitly added to the staging area using git add and are waiting to be permanently recorded with a git commit command.

5.4 Committing Staged Changes (git commit)

1. Commit Changes: Use the git commit command to create a commit. It’s essential to include a commit message to describe the changes you are saving. Use the -m flag followed by your message in quotation marks:

   • git commit -m "Added initial text file"

2. Configure User Identity (if prompted): If this is your first commit, Git might prompt you to configure your user name and email. This information is recorded with each commit. Use the following commands, replacing "Your Name" and "[email protected]" with your actual details:

   • git config --global user.email "[email protected]"
   • git config --global user.name "Your Name"
   • After configuring your identity, re-run the git commit command.

3. Check Status After Commit: Run git status. You should see “nothing to commit, working tree clean.” This means your changes have been successfully committed, and your working directory is in sync with the latest commit.

5.5 Viewing Commit History (git log)

1. View Commit Log: Type git log and press Enter. This command displays the commit history for the current branch.
   • You’ll see information about each commit, including:
     • Commit ID (SHA): A unique identifier for each commit.
     • Author: Your name and email (as configured).
     • Date: Timestamp of the commit.
     • Commit Message: The message you provided when creating the commit.
   • Press q to quit the git log view.

5.6 Creating and Switching Branches (git branch, git checkout)

1. List Branches: Type git branch and press Enter. This command lists all branches in your repository. Initially, you’ll only see the master (or main) branch, indicated by an asterisk * and green highlighting.

2. Create a New Branch: To create a new branch named “second-branch,” use:

   • git branch second-branch

3. List Branches Again: Run git branch again. You’ll now see both master and second-branch listed, but you are still on the master branch (indicated by the asterisk).

4. Switch to a Branch: To switch to the “second-branch,” use the git checkout command:

   • git checkout second-branch
   • You’ll see a confirmation message “Switched to branch ‘second-branch’.” git branch will now show the asterisk next to second-branch.

5. Create and Checkout a Branch in One Step (Shortcut): You can create and switch to a new branch in a single command using git checkout -b:

   • git checkout -b third-branch
   • This creates a branch named “third-branch” and immediately switches you to it.

5.7 Working on a Branch and Committing Changes

1. Make Changes on the Branch: While on the “third-branch,” create a new file (e.g., working-with-branches.txt) and add some text to it. Save the file.
2. Stage and Commit Changes: Use git add working-with-branches.txt and then git commit -m "Added branches text file" to stage and commit the new file on the “third-branch.”
3. View Log on the Branch: git log will show the commit you just made on “third-branch,” along with the previous commits from the base branch (likely master).

5.8 Switching Back to Master Branch

1. Switch to Master: Use git checkout master to switch back to the master branch.
2. Observe File Changes: Notice that the working-with-branches.txt file you created on “third-branch” disappears from your working directory when you switch back to “master.” This is because branches are isolated.
3. View Log on Master: git log on the master branch will not show the “Added branches text file” commit, as that commit exists only on the “third-branch.”

5.9 Merging Branches (git merge)

1. Checkout Master Branch: Ensure you are on the master branch (git checkout master).
2. Merge Third-Branch into Master: To bring the changes from “third-branch” into “master,” use the git merge command, specifying the branch to merge from:
   • git merge third-branch
   • Git will attempt to automatically merge the changes. In simple cases like this, it will likely be a “fast-forward” merge.
3. Observe File Changes After Merge: After merging, you will see that the working-with-branches.txt file now appears in your working directory on the master branch.
4. View Log on Master After Merge: git log on the master branch will now show the “Added branches text file” commit from “third-branch,” indicating that the changes have been successfully merged into the master branch.

Conclusion

This chapter has provided a comprehensive introduction to Git and GitHub, covering the fundamental concepts of version control, the roles of Git and GitHub, and a basic Git workflow. You have learned how to initialize a Git repository, stage and commit changes, work with branches, and merge branches. These are the foundational skills necessary to begin using Git for your projects and collaborative endeavors. Further exploration of advanced Git features and GitHub functionalities will build upon this solid understanding.