Objective

In this unit, you will learn the fundamentals of managing and collaborating on code projects using Git and GitHub. You'll explore how to set up Git, create and manage repositories, connect to GitHub, and work with branches. By the end of this unit, you'll be able to create a project for your Turtle program, manage it using Git, push it to a GitHub repository, and understand the basics of collaborating with others in a software development environment.

Introduction to Version Control Systems

Version control systems (VCS) are essential tools in software development that help manage changes to code over time. Imagine working on a document and wanting to track changes, revert to previous versions, or collaborate with others. VCS provides these capabilities for code. Git is one of the most widely used VCS, and GitHub is a platform that hosts Git repositories, making collaboration easier.

Setting Up Git

  1. Installation:

    • Windows: Download and install Git for Windows.
    • Mac: Use Homebrew to install Git: brew install git.
    • Linux: Use your package manager, e.g., sudo apt-get install git on Ubuntu.

  2. Configuration: Set up your name and email, which will be associated with your commits:

    git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"

    Set the default branch name to main:

    git config --global init.defaultBranch main

Creating a Local Repository

A Git repository is like a folder where Git tracks changes to files. Here's how to create one:

  1. Navigate to Directory: Open your command line and navigate to the directory where you want to store your code:

    cd path/to/your/directory

  2. Initialize Repository: Run this command to create a new Git repository:

    git init

Connecting to GitHub

GitHub is like a cloud storage for your Git repositories. Here's how to connect your local repository to GitHub:

  1. Sign up for a GitHub Account: Sign up to create a GitHub account, if you already don't have one. There is no charge for their basic account that allows for unlimited public and private repositories.

  2. Create a GitHub Repository: Create a new repository.

  3. Link to Local Repository: In your command line, run:

    git remote add origin https://github.com/<username>/<repo-name>.git

    Replace username and repo-name with your GitHub username and repository name.

Pushing Code to GitHub

Here's how to save your code changes and upload them to GitHub:

  1. Add Changes: This command stages all your changes for commit:

    git add .

  2. Commit Changes: This saves your changes with a message describing what you did:

    git commit -m "Initial commit"

  3. Push to GitHub: This uploads your code to GitHub:

    git push -u origin main

Working with Branches

Branches are like parallel universes for your code. You can make changes without affecting the main code:

  1. Create a Branch: This creates and switches to a new branch:

    git checkout -b <new-branch-name>

  2. Switch Between Branches: Use this to switch:

    git checkout <branch-name>

  3. Merge Changes: This combines changes from one branch into another:

    git merge <branch-name>

Collaborating with Others

GitHub makes collaboration easy:

  • Invite Collaborators: You can invite others to work on your repository.
  • Pull Requests: These are requests to merge changes from one branch to another, allowing for code review.
  • Issues: You can track bugs, enhancements, tasks, and other kinds of questions.

Best Practices and Common Git Commands

  • Commit Often: Small, frequent commits make it easier to understand what happened.
  • Write Clear Commit Messages: Describe what and why, not just how.
  • Use Branches: Keep different features or fixes isolated.
  • Keep Synced: Regularly update your code with the latest changes from others.

Common commands:

  • git status: See what's changed.
  • git log: View history.
  • git pull: Update your code from GitHub.

Project: Create a Project for Your Turtle Program

In this project, you'll apply what you've learned about Git and GitHub by creating a Python project for a simple drawing program using Turtle. You'll manage the project using Git, push it to a GitHub repository, and simulate a real-world collaboration workflow.

Step 1: Create a Python Project

Start by creating a new project folder and creating a Python file for your Turtle drawing program. You can create a simple program that draws shapes based on user input.

Here's an example code:

import turtle

def draw_shape(sides):
    for _ in range(sides):
        turtle.forward(100)
        turtle.left(360 / sides)

sides = int(input("Enter the number of sides for the shape: "))
draw_shape(sides)
turtle.done()

Step 2: Initialize a Git Repository and Make Initial Commits

Navigate to your project folder in the command line and initialize a Git repository:

cd path/to/your/directory
git init
git add .
git commit -m "Initial commit"

Step 3: Create a GitHub Repository and Push the Code

Create a new repository on GitHub and link it to your local repository:

git remote add origin https://github.com/<username>/<repo-name>.git
git push -u origin main

Replace <username> and <repo-name> with your GitHub username and repository name.

Step 4: Make Changes in a Branch, Create a PR, and Merge It

Create a new branch for your changes:

git checkout -b feature-branch

Make changes to your code, then stage and commit them:

git add .
git commit -m "Added new feature"

Push the changes to GitHub:

git push origin feature-branch

Go to your repository on GitHub and create a Pull Request (PR) for your changes. Review the changes, merge the PR, and delete the branch if desired.

Step 5: Switch Back to Main Branch and Pull Latest Changes

After merging the PR, switch back to the main branch locally:

git checkout main

Pull the latest changes from the remote server:

git pull origin main

Delete the feature branch locally if you no longer need it:

git branch -d feature-branch

In this unit you've gained hands-on experience with Git and GitHub, managing a real Python project from creation to collaboration. You've learned how to initialize repositories, make commits, create branches, push code to GitHub, and work with PRs. These skills are foundational for modern software development and will serve you well in future projects.

In the next unit, we'll explore how to use Poetry to manage the dependencies of a Python project.