Creating Your First GitHub Repository

Python Full Stack Web Developer Course - Week 1: Tuesday

The Gateway to Collaborative Coding

A GitHub repository is the digital home for your project. It's where your code lives, evolves, and collaborates with other developers. Creating your first repository is a significant milestone in your development journey—it's the moment your code becomes part of the larger programming ecosystem.

Think of a GitHub repository as a project workspace that includes not just your code, but also its complete history, documentation, and collaborative tools. It's akin to an artist's studio where every brushstroke is recorded, every iteration is saved, and multiple artists can contribute to the canvas.

Whether you're building a personal project, contributing to open source, or working in a development team, the skills you'll learn today will form the foundation of your collaborative coding practices. By the end of this session, you'll have created your first GitHub repository and understood the key concepts that will enable you to work effectively with version control in your future projects.

Setting Up Your GitHub Account

Creating a GitHub Account

Before creating a repository, you need a GitHub account. If you already have one, you can skip to the next section.

  1. Visit GitHub: Go to github.com
  2. Sign up: Click the "Sign up" button and follow these steps:
    • Enter your email address
    • Create a password (use a strong, unique password)
    • Choose a username (this will be part of your repository URLs, so choose wisely)
    • Complete the verification puzzle
    • Click "Create account"
  3. Verify your email: Check your inbox for a verification email from GitHub and click the verification link
  4. Complete profile: Add a profile picture and basic information

Choosing a Good GitHub Username

Your GitHub username is an important part of your professional identity as a developer. Consider these tips when selecting a username:

Remember that your GitHub profile will likely become part of your professional portfolio, so choose a username that represents you well.

Setting Up Two-Factor Authentication (2FA)

Securing your GitHub account is crucial, especially as your repositories become more valuable. Two-factor authentication adds an extra layer of security beyond just your password.

  1. Go to Settings: Click your profile picture in the top-right corner and select "Settings"
  2. Find Security Options: In the left sidebar, click "Password and authentication"
  3. Enable 2FA: Click "Enable two-factor authentication"
  4. Choose a Method:
    • Authenticator app (recommended): Use apps like Google Authenticator, Authy, or Microsoft Authenticator
    • SMS authentication: Receive codes via text message (less secure but better than no 2FA)
  5. Save Recovery Codes: Store the provided recovery codes in a secure place

Two-factor authentication protects your code and contributions from unauthorized access. As you build more repositories and contribute to more projects, this security becomes increasingly important.

Planning Your Repository

Types of GitHub Repositories

Before creating a repository, it's helpful to understand the different types of repositories you might create:

The purpose of your repository will influence how you structure it, what documentation you include, and which settings you choose.

Public vs. Private Repositories

GitHub offers both public and private repositories, each with its own advantages:

Public Repositories Private Repositories
Visible to everyone on the internet Visible only to you and collaborators you invite
Great for open-source projects Suitable for proprietary code or personal experiments
Showcases your work to potential employers Keeps sensitive projects confidential
Enables collaboration with the wider community Limits collaboration to specific team members
Free for unlimited repositories Free for unlimited repositories (with limitations on features for free accounts)

For learning purposes or personal projects you're proud of, public repositories are often the best choice. They allow others to see your work and potentially contribute, while helping you build a visible portfolio of your coding skills.

Repository Naming Conventions

A good repository name is clear, descriptive, and follows conventions that make it easy to understand. Consider these guidelines:

Example naming patterns for different types of repositories:

For this course, you might consider a name like "python-fullstack-portfolio" for a repository that will showcase your progress and projects.

Creating Your First Repository

Step-by-Step Repository Creation

Now that you've planned your repository, let's create it on GitHub:

  1. Sign in to GitHub: Log in to your GitHub account at github.com
  2. Start the creation process: Click the "+" icon in the top-right corner of the page and select "New repository" from the dropdown menu
  3. Fill in repository details:
    • Repository name: Enter a name following the conventions discussed earlier
    • Description: Add a short, clear description of your repository (this will appear on your repository's page)
    • Visibility: Choose between Public or Private
  4. Initialize repository options:
    • Add a README file: Check this box to create an initial README.md file (highly recommended)
    • Add .gitignore: Select a template based on your project type (e.g., Python)
    • Choose a license: Select an appropriate license for your project
  5. Create repository: Click the "Create repository" button at the bottom of the page

Congratulations! You've just created your first GitHub repository. You'll be redirected to your new repository's page, which includes the README.md file and other files you chose to initialize with.

Understanding Repository Initialization Options

Let's look more closely at the initialization options and why they're important:

README File

The README.md file is typically the first thing people see when they visit your repository. It serves as the welcome page and should explain:

The .md extension stands for Markdown, a lightweight markup language that allows you to format text with simple syntax. GitHub automatically renders Markdown files as formatted HTML on your repository page.

.gitignore File

The .gitignore file tells Git which files or directories to ignore in your project. This is useful for:

GitHub offers templates for various programming languages and frameworks. For Python projects, the template includes patterns for:

License File

The license defines how others can use, modify, and distribute your code. Common licenses include:

For learning projects or personal code you want others to use, the MIT License is often a good choice due to its simplicity and permissiveness.

Exploring Your New Repository

After creating your repository, take some time to explore its interface:

This interface provides all the tools you need to manage your code, collaborate with others, and maintain your project over time.

Editing and Managing Your Repository

Editing Files Directly on GitHub

GitHub allows you to create, edit, and delete files directly through the web interface, which is useful for quick changes or when you don't have access to your local development environment.

Editing the README.md
  1. Navigate to the file: Click on the README.md file in your repository's file list
  2. Enter edit mode: Click the pencil icon (Edit this file) in the upper right corner of the file view
  3. Make changes: Edit the content using Markdown syntax
  4. Preview changes: Click the "Preview" tab to see how your changes will look
  5. Commit changes: Scroll down to the "Commit changes" section
    • Add a commit message describing your changes
    • Optionally, add an extended description
    • Choose whether to commit directly to the main branch or create a new branch and pull request
    • Click "Commit changes"
Creating a New File
  1. Navigate to your repository: Go to the main page of your repository
  2. Click "Add file": Use the "Add file" dropdown and select "Create new file"
  3. Name your file: Enter a filename with appropriate extension (e.g., "hello.py")
  4. Add content: Type or paste the file content
  5. Commit the new file: Follow the same commit process as when editing
Uploading Files
  1. Navigate to your repository: Go to the main page of your repository
  2. Click "Add file": Use the "Add file" dropdown and select "Upload files"
  3. Select files: Drag and drop files or use the file chooser
  4. Commit uploaded files: Add a commit message and commit the changes

Creating a Meaningful README

A well-crafted README is essential for any repository. Here's a template for a good README structure:

# Project Name A brief description of what this project does and who it's for. ## Features - Feature 1: Description - Feature 2: Description - Feature 3: Description ## Installation ```bash # Example installation commands pip install package-name ``` ## Usage ```python # Example code showing how to use your project from package import function function() ``` ## Contributing Contributions are welcome! Please feel free to submit a Pull Request. ## License [MIT](https://choosealicense.com/licenses/mit/)

For this course, you might start with a README that includes:

Using Markdown Effectively

Markdown is a simple markup language that allows you to format text without HTML. Here are some common Markdown syntaxes:

# Heading 1 ## Heading 2 ### Heading 3 **Bold text** *Italic text* - Bullet point - Another bullet point - Nested bullet point 1. Numbered item 2. Another numbered item [Link text](https://www.example.com) ![Alt text for image](image-url.jpg) `Inline code` ```python # Code block def hello_world(): print("Hello, World!") ``` > Blockquote | Table | Header | |-------|--------| | Cell | Cell | | Cell | Cell |

Using Markdown effectively makes your documentation more readable and professional-looking. GitHub's editor includes a toolbar with Markdown formatting options to help you get started.

Repository Settings

Your repository has various settings that control its behavior and appearance. To access these:

  1. Navigate to your repository
  2. Click the "Settings" tab near the top of the page

Key settings to be aware of include:

For your first repository, the default settings are usually appropriate, but it's good to know where these options are for future projects.

Connecting Your Local Development Environment

Cloning Your Repository Locally

While GitHub's web interface is useful for simple edits, most development work happens on your local machine. To get a local copy of your repository:

  1. Navigate to your repository on GitHub
  2. Click the "Code" button: This opens a dropdown with clone options
  3. Choose a clone method:
    • HTTPS: Works through firewalls, but requires you to enter your password for pushes
    • SSH: More secure and allows passwordless pushing if you've set up SSH keys
    • GitHub CLI: If you have the GitHub CLI installed
  4. Copy the URL: Click the copy button next to the URL
  5. Open your terminal or command prompt
  6. Navigate to where you want to clone the repository:
    $ cd path/to/desired/directory
  7. Clone the repository:
    $ git clone https://github.com/your-username/your-repository.git
  8. Navigate into your cloned repository:
    $ cd your-repository

Now you have a local copy of your repository that you can work with using your preferred code editor and development tools.

Making Changes Locally

Once you have a local clone, you can make changes to your files using any editor or IDE. Here's the basic workflow:

  1. Make changes to your files: Add code, modify files, create new files, etc.
  2. Stage changes: Mark the changes you want to include in your commit
    $ git add filename.py $ git add .
  3. Commit changes: Create a snapshot with a descriptive message
    $ git commit -m "Add user authentication function"
  4. Push changes to GitHub: Upload your local commits to your GitHub repository
    $ git push origin main

After pushing, your changes will be visible on GitHub, and your local and remote repositories will be synchronized.

Setting Up Git for the First Time

If this is your first time using Git on your computer, you'll need to configure it with your identity. This information is used to attribute your commits.

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

Use the same email address associated with your GitHub account to ensure your commits are properly linked to your GitHub profile.

Authentication Options

There are several ways to authenticate with GitHub when pushing changes:

HTTPS with Personal Access Token
  1. Generate a token: Go to GitHub → Settings → Developer settings → Personal access tokens → Generate new token
  2. Set token scope: Select "repo" for full repository access
  3. Use the token: When prompted for a password during git push, enter the token instead of your account password
SSH Key Authentication (Recommended)
  1. Check for existing SSH keys:
    $ ls -la ~/.ssh
  2. Generate new SSH key if needed:
    $ ssh-keygen -t ed25519 -C "your.email@example.com"
  3. Add SSH key to ssh-agent:
    $ eval "$(ssh-agent -s)" $ ssh-add ~/.ssh/id_ed25519
  4. Add SSH key to GitHub account:
    • Copy the public key to clipboard:
      $ cat ~/.ssh/id_ed25519.pub
    • Go to GitHub → Settings → SSH and GPG keys → New SSH key
    • Paste your key and give it a descriptive title
  5. Test the connection:
    $ ssh -T git@github.com

With SSH key authentication set up, you won't need to enter your password each time you push to GitHub.

Common Repository Patterns and Structures

Basic Python Project Structure

For Python projects, it's helpful to follow a standardized directory structure. Here's a common pattern:

project_name/ ├── LICENSE ├── README.md ├── requirements.txt ├── setup.py ├── .gitignore ├── project_name/ │ ├── __init__.py │ ├── main.py │ └── utils.py └── tests/ ├── __init__.py ├── test_main.py └── test_utils.py

This structure separates your actual code (in the inner project_name directory) from project metadata and tests, making it clear and organized.

Web Application Structure

For web applications (like Flask or Django projects), the structure might look like this:

web_app/ ├── LICENSE ├── README.md ├── requirements.txt ├── .gitignore ├── app.py ├── config.py ├── static/ │ ├── css/ │ ├── js/ │ └── images/ ├── templates/ │ ├── base.html │ ├── home.html │ └── about.html └── tests/ └── test_app.py

This organization separates static assets, templates, and application code, following web development best practices.

Documentation-Focused Repository

If your repository is primarily for documentation or course notes, consider a structure like this:

course_notes/ ├── README.md ├── LICENSE ├── week_1/ │ ├── lecture_notes.md │ ├── exercises.md │ └── resources.md ├── week_2/ │ ├── lecture_notes.md │ ├── exercises.md │ └── resources.md └── projects/ ├── project_1/ └── project_2/

This approach organizes content chronologically and by topic, making it easy to navigate.

Essential Files for Every Repository

Regardless of your project type, certain files should be included in almost every repository:

These files help others understand, use, and potentially contribute to your project.

Special Repository Types

GitHub has some special repository types with unique patterns:

GitHub Pages Personal Site

If you name a repository username.github.io, it will be published as a website at https://username.github.io.

Template Repositories

You can mark a repository as a template, allowing others to create new repositories with the same structure and files.

.github Repository

A special repository named .github can contain default files (like issue templates) that apply to all your other repositories.

Best Practices for GitHub Repositories

Documentation

Commit Practices

Branch Management

Repository Maintenance

Security Practices

Hands-On Exercise: Create Your Course Repository

Now it's time to put everything you've learned into practice by creating a repository for this course. This repository will serve as a portfolio of your work and a reference for what you've learned.

Step 1: Create a New Repository on GitHub

  1. Go to GitHub and sign in
  2. Click the "+" icon and select "New repository"
  3. Name your repository "python_fullstack_course"
  4. Add a description: "My journey learning Full Stack Python development"
  5. Make the repository Public
  6. Check "Add a README file"
  7. Add a .gitignore with the Python template
  8. Choose a license (MIT is recommended for this exercise)
  9. Click "Create repository"

Step 2: Enhance Your README.md

  1. Click on the README.md file in your repository
  2. Click the pencil icon to edit
  3. Replace the content with a more detailed introduction:
    # Python Full Stack Developer Course Welcome to my learning journey as a Full Stack Python Developer! ## About Me [Introduce yourself briefly - your background, interests, and why you're taking this course] ## Course Goals By the end of this course, I aim to: - Master Python programming fundamentals - Develop web applications using Flask and Django - Understand database design and implementation - Build RESTful APIs - Create responsive front-end interfaces - Deploy applications to production environments ## Projects This repository will contain various projects completed during the course, including: 1. **Command-line To-Do Application** (Week 3) 2. **Personal Portfolio Website** (Week 4-5) 3. **Flask Web Application** (Week 6-7) 4. **RESTful API** (Week 8-9) 5. **Full Stack Application** (Week 10-14) ## Weekly Progress ### Week 1 - Introduction to version control with Git - Setting up development environments - Creating my first GitHub repository [This section will expand as I progress through the course] ## Resources This section will include helpful resources I discover throughout the course. ## Contact Feel free to reach out to me at [your-email@example.com] or connect on [LinkedIn/Twitter/etc.].
  4. Commit your changes with a descriptive message

Step 3: Create a Basic Directory Structure

  1. Click "Add file" → "Create new file"
  2. Name the file "week_1/notes.md" (this will automatically create the week_1 directory)
  3. Add content to your notes file:
    # Week 1 Notes ## Git and GitHub Basics ### Key Git Commands - `git init`: Initialize a repository - `git add`: Stage changes - `git commit`: Record changes to the repository - `git status`: Check repository status - `git log`: View commit history ### Creating a GitHub Repository Steps I followed to create this repository: 1. Signed in to GitHub 2. Clicked the "+" icon and selected "New repository" 3. Named the repository "python_fullstack_course" 4. Added a description 5. Made the repository public 6. Checked "Add a README file" 7. Added a Python .gitignore template 8. Chose the MIT license 9. Clicked "Create repository" ### Reflections What I found most interesting about Git and GitHub is... What I found most challenging is...
  4. Commit your new file

Step 4: Clone the Repository Locally

  1. Click the "Code" button on your repository page
  2. Copy the repository URL (HTTPS or SSH, depending on your setup)
  3. Open your terminal or command prompt
  4. Navigate to where you want to store the repository
  5. Clone the repository:
    $ git clone https://github.com/your-username/python_fullstack_course.git
  6. Navigate into the repository:
    $ cd python_fullstack_course

Step 5: Add a Simple Python Script Locally

  1. Create a new file named "week_1/hello.py"
  2. Add this simple Python code:
    #!/usr/bin/env python3 """ My first Python script in the Full Stack course. """ def greet(name): """ Return a personalized greeting. Args: name (str): The name to greet Returns: str: Personalized greeting """ return f"Hello, {name}! Welcome to my Python Full Stack journey." if __name__ == "__main__": import sys if len(sys.argv) > 1: name = sys.argv[1] else: name = input("Enter your name: ") print(greet(name)) print("This is my first Python script committed to GitHub!")
  3. Stage your new file:
    $ git add week_1/hello.py
  4. Commit your changes:
    $ git commit -m "Add first Python script"
  5. Push your changes to GitHub:
    $ git push origin main

Step 6: Create a .github Directory

  1. Create a new file named ".github/ISSUE_TEMPLATE/bug_report.md"
  2. Add a simple issue template:
    --- name: Bug report about: Create a report to help improve the project title: '[BUG] ' labels: bug assignees: '' --- **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behavior: 1. Go to '...' 2. Click on '....' 3. Scroll down to '....' 4. See error **Expected behavior** A clear and concise description of what you expected to happen. **Screenshots** If applicable, add screenshots to help explain your problem. **Additional context** Add any other context about the problem here.
  3. Commit and push this file as before

Step 7: Review Your Repository

  1. Visit your repository on GitHub
  2. Explore the files and directories you've created
  3. Click through the commit history to see your progress
  4. Check how your README is displayed on the main page

Congratulations! You've created a well-structured repository for your course work, complete with documentation, organization, and your first code sample. As you progress through the course, you'll continue to add projects, notes, and code to this repository, building a comprehensive portfolio of your skills.

Additional GitHub Features Worth Exploring

GitHub Pages

GitHub Pages allows you to host websites directly from your GitHub repositories. This is perfect for project documentation, personal websites, or showcasing your portfolio.

To enable GitHub Pages:

  1. Go to your repository's Settings
  2. Scroll down to the "GitHub Pages" section
  3. Select a source branch (usually main) and folder (/ or /docs)
  4. Click Save

Your site will be published at https://username.github.io/repository-name/

GitHub Actions

GitHub Actions allow you to automate workflows directly in your GitHub repository. You can set up actions to:

Actions are defined in YAML files in the .github/workflows directory.

GitHub Projects

GitHub Projects help you organize and prioritize your work. You can create project boards with columns representing different stages of work (e.g., To Do, In Progress, Done) and move issues and pull requests between them.

GitHub Discussions

Discussions provide a forum-like space for questions, ideas, and conversations related to your repository. Unlike issues, which are typically focused on specific tasks or bugs, discussions are meant for broader topics and community engagement.

GitHub Codespaces

Codespaces are cloud-based development environments that allow you to code, build, test, and debug directly in your browser. They come with a web-based VS Code editor and a full development environment configured for your repository.

Key Takeaways

Creating your first GitHub repository is an important milestone in your development journey. It establishes a foundation for version control, collaboration, and showcasing your work. As you continue to build and contribute to repositories, your skills and your digital presence will grow together.

Remember that GitHub is more than just a code hosting platform—it's a community of developers sharing, collaborating, and learning together. Your repositories are your contributions to this community, whether they're personal projects, open-source contributions, or collaborative team efforts.

Assignment: Create a Personal Portfolio Repository

For this assignment, you'll create a GitHub repository to serve as your personal portfolio. This repository will showcase your skills, projects, and growth as a developer.

Requirements

  1. Create a new repository:
    • Name: "portfolio" or "your-username.github.io" (if you want to use GitHub Pages)
    • Make it public
    • Initialize with a README, .gitignore (choose one appropriate for your projects), and license
  2. Enhance the README with:
    • A professional introduction about yourself
    • Your skills and technologies
    • A summary of your projects (with links if they're on GitHub)
    • Your educational background
    • Contact information or links to your professional profiles
  3. Create project directories:
    • Create at least 3 directories for different types of projects (e.g., "web-projects", "python-scripts", "data-analysis")
    • Add a README.md file in each directory explaining what types of projects will go there
  4. Add a sample project:
    • Choose a simple project you've already completed or create a new one
    • Add it to the appropriate directory
    • Include a project-specific README explaining what it does and how to use it
  5. Use GitHub Pages (optional):
    • Enable GitHub Pages for your repository
    • Create an index.html file with a simple portfolio page
    • Include links to your projects
  6. Make at least 7 commits:
    • Initial repository creation
    • Enhanced README
    • Directory structure
    • Sample project
    • Project-specific documentation
    • GitHub Pages setup (if applicable)
    • Final refinements

Submission

Submit the URL to your GitHub repository. Make sure it's public so it can be viewed for grading.

Evaluation Criteria

Bonus Challenges

This assignment will not only help you practice GitHub repository creation but also start building a professional portfolio that you can share with potential employers or collaborators.

Additional Resources

GitHub Documentation

Git and GitHub Tutorials

Markdown Resources

GitHub Portfolio Examples

Project Structure Guidelines

Books