Beyond Local: The Power of Remote Repositories
So far, we've explored Git as a tool for tracking changes in your local projects. However, the true magic of version control emerges when we move beyond a single developer's computer and enable collaboration with others. This is where remote repositories and platforms like GitHub enter the picture.
Think of your local Git repository as your personal workshop, where you craft and refine your code. GitHub, then, is like a global exhibition hall where you can showcase your work, invite collaboration, and discover creations from developers around the world. It transforms Git from a personal tool into a social coding platform that powers much of modern software development.
In this session, we'll dive into GitHub and remote repositories, learning how to share your code with the world and collaborate effectively with other developers. Whether you're working on open-source projects, contributing to company repositories, or simply backing up your personal projects, understanding remote repositories is an essential skill for any developer.
Understanding Remote Repositories
What is a Remote Repository?
A remote repository is a version of your project that is hosted on the internet or a network. It serves as a central coordination point between different developers and their local repositories.
Think of a remote repository as a library where everyone can check out and return books. Each developer works with their own copy, but eventually, all changes are returned to the central library for others to access.
Key Benefits of Remote Repositories
- Collaboration: Multiple developers can work on the same project from different locations
- Backup: Your code is safely stored in the cloud, protected from local hardware failures
- Visibility: Your projects can be discovered by other developers and potential employers
- Project Management: Many remote repository platforms offer tools for issue tracking, project planning, and code review
- Continuous Integration: Remote repositories can be connected to CI/CD pipelines for automated testing and deployment
Common Remote Repository Hosts
- GitHub - The most popular platform, owned by Microsoft, with over 100 million repositories
- GitLab - A complete DevOps platform that offers repository hosting plus CI/CD, issue tracking, and more
- Bitbucket - Popular particularly in enterprise environments, integrates well with other Atlassian products
- Azure DevOps - Microsoft's developer service with Git repositories, CI/CD, and project management tools
For this course, we'll focus on GitHub as it's the most widely used platform and has become the de facto standard for open-source collaboration.
Introduction to GitHub
What is GitHub?
GitHub is a web-based platform that hosts Git repositories. Founded in 2008 and acquired by Microsoft in 2018, GitHub has become the world's largest code host with over 100 million developers and 330 million repositories.
But GitHub is much more than just a storage space for code. It's a comprehensive platform that adds a social and collaborative layer on top of Git. Think of it as social media for code - a place where developers share their work, collaborate on projects, and build their professional reputation.
Key GitHub Features
- Repository Hosting: Store your Git repositories in the cloud with unlimited public repositories
- Collaboration Tools: Pull requests, code reviews, and issue tracking facilitate teamwork
- Project Management: Project boards, milestones, and automated workflows streamline development
- Social Coding: Follow other developers, star repositories, and contribute to open-source projects
- Documentation: README files, wikis, and GitHub Pages help document and showcase your projects
- Security: Vulnerability scanning, dependency management, and access controls protect your code
- Integration: Connect with thousands of tools through GitHub Marketplace and webhooks
Public vs. Private Repositories
GitHub offers both public and private repositories:
- Public repositories are visible to everyone on the internet. They're free and ideal for open-source projects or showcasing your work to potential employers.
- Private repositories are only visible to you and collaborators you explicitly invite. They're useful for proprietary projects or code you're not ready to share publicly.
For learning purposes, both types work equally well. You might start with private repositories while you're building confidence, then transition to public repositories to showcase your skills.
Setting Up GitHub
Creating a GitHub Account
- Visit github.com
- Fill in your email address, create a password, and choose a username
Tip: Choose a professional username that you wouldn't mind future employers seeing. Many developers use their real name or a recognizable handle they use across platforms.
- Verify your account through the email GitHub sends you
- Optionally, set up two-factor authentication for increased security
Configuring Your Profile
Your GitHub profile is your developer identity card. It's worth taking time to set it up properly:
- Add a profile picture (a professional photo or avatar)
- Fill in your bio with relevant information about your skills and interests
- Add your location and (optionally) company information
- Link to your personal website or social profiles
- Pin your most impressive repositories to the top of your profile
A well-crafted profile helps you stand out to potential collaborators and employers.
Setting Up SSH Authentication (Recommended)
While GitHub supports HTTPS authentication, SSH is more secure and convenient for frequent use. Here's how to set it up:
- Check for existing SSH keys:
$ ls -al ~/.sshLook for files named id_rsa.pub, id_ecdsa.pub, or id_ed25519.pub
- Generate a new SSH key if needed:
$ ssh-keygen -t ed25519 -C "your_email@example.com"When prompted, press Enter to accept the default file location. You may enter a passphrase for extra security or press Enter for no passphrase.
- Start the SSH agent:
$ eval "$(ssh-agent -s)" - Add your SSH key to the agent:
$ ssh-add ~/.ssh/id_ed25519 - Copy your public key:
$ cat ~/.ssh/id_ed25519.pubThis will display your public key, which you should copy.
- Add the key to your GitHub account:
- Go to your GitHub account settings
- Click on "SSH and GPG keys"
- Click "New SSH key"
- Give your key a descriptive title (e.g., "Personal Laptop")
- Paste your key into the "Key" field
- Click "Add SSH key"
- Test your connection:
$ ssh -T git@github.comYou should see a greeting message from GitHub, confirming your authentication is working.
Configuring Git for GitHub
Ensure your local Git configuration matches your GitHub account:
$ git config --global user.name "Your Name"
$ git config --global user.email "your_email@example.com"
Use the same email address that you registered with GitHub to ensure your commits are properly attributed to your account.
Creating and Connecting to Remote Repositories
Creating a New Repository on GitHub
- Start the creation process:
- Click the "+" icon in the top-right corner of GitHub
- Select "New repository"
- Configure your repository:
- Owner: Your username or an organization you belong to
- Repository name: Choose a clear, descriptive name (e.g., "python_todo_app")
- Description: Add a brief explanation of your project
- Visibility: Choose Public or Private
- Initialize options:
- Add a README file (optional, but recommended)
- Add .gitignore (choose Python template for Python projects)
- Choose a license (MIT is popular for open-source projects)
- Create repository: Click the "Create repository" button
Once created, GitHub will display instructions for connecting your local repository to this remote repository.
Connecting an Existing Local Repository to GitHub
If you already have a local repository (like our python_todo_app from previous exercises), you can connect it to a new GitHub repository:
- Create a new repository on GitHub (without initializing it with README, .gitignore, or license)
- Copy the repository URL:
GitHub will provide a URL for your empty repository. For SSH, it looks like:
git@github.com:username/repository-name.git - Navigate to your local repository:
$ cd ~/path/to/your/repository - Add the remote:
$ git remote add origin git@github.com:username/repository-name.gitThis command creates a remote connection named "origin" pointing to your GitHub repository.
- Verify the remote was added:
$ git remote -vThis should display the fetch and push URLs for your remote.
- Push your local repository to GitHub:
$ git push -u origin mainThis uploads your local repository to GitHub. The
-uflag sets up tracking, which simplifies future push/pull commands.
Cloning an Existing GitHub Repository
To create a local copy of a repository that already exists on GitHub:
- Find the repository you want to clone on GitHub
- Click the "Code" button and copy the URL:
- For SSH:
git@github.com:username/repository-name.git - For HTTPS:
https://github.com/username/repository-name.git
- For SSH:
- Open your terminal and navigate to where you want the repository to be cloned
- Clone the repository:
$ git clone git@github.com:username/repository-name.gitThis creates a new directory with the repository name and downloads all files and history.
- Navigate into the cloned repository:
$ cd repository-name
When you clone a repository, Git automatically sets up the remote connection for you, naming it "origin".
Working with Remote Repositories
Understanding Remote Operations
Working with remote repositories involves a few key operations:
- Pushing: Uploading local commits to the remote repository
- Pulling: Downloading and integrating remote changes into your local repository
- Fetching: Downloading remote changes without automatically integrating them
- Forking: Creating your own copy of someone else's repository on GitHub
Let's explore each of these operations in detail.
Pushing Changes to GitHub
After making commits locally, you can share them with others by pushing to GitHub:
- Make some changes to your project
- Stage and commit your changes:
$ git add file.py$ git commit -m "Add feature X" - Push your commits to GitHub:
$ git pushIf you've set up tracking with
-u, you can simply usegit push. Otherwise, specify the remote and branch:$ git push origin main - Verify on GitHub that your changes have been uploaded
Push regularly to keep your remote repository up-to-date with your local work.
Pulling Changes from GitHub
When others (or you from another computer) have pushed changes to the remote repository, you'll need to incorporate those changes into your local repository:
- Pull the latest changes:
$ git pullThis is equivalent to
git fetchfollowed bygit merge. It downloads changes and automatically integrates them into your current branch. - Resolve any merge conflicts if they occur
- Continue working with the updated code
It's a good practice to pull before starting work each day to ensure you have the latest changes.
Fetching vs. Pulling
Sometimes you may want to see what's changed without automatically merging:
$ git fetch
Fetching downloads changes but doesn't integrate them. After fetching, you can:
- Examine changes:
git diff origin/main - Merge when ready:
git merge origin/main - Or combine both with pull:
git pull
Fetch is useful when you want to review changes before integrating them, especially in complex projects.
Managing Remotes
You can have multiple remotes for a single repository. Here are some common remote management commands:
- List remotes:
$ git remote -v - Add a new remote:
$ git remote add upstream git@github.com:original-owner/repository-name.gitThis is common when working with forked repositories, where "origin" is your fork and "upstream" is the original repository.
- Change a remote's URL:
$ git remote set-url origin git@github.com:new-username/repository-name.git - Remove a remote:
$ git remote remove upstream
Common GitHub Workflows
The Basic Collaborative Workflow
For simple collaboration on a shared repository, here's a typical workflow:
- Pull the latest changes:
$ git pull origin main - Create a branch for your feature:
$ git checkout -b feature-name - Work on your changes, making regular commits:
$ git add .$ git commit -m "Implement feature X" - Push your branch to GitHub:
$ git push -u origin feature-name - Create a Pull Request (PR) on GitHub:
- Navigate to your repository on GitHub
- GitHub will often show a prompt to create a PR from your recently pushed branch
- Otherwise, click the "Pull requests" tab and then "New pull request"
- Select your branch as the "compare" branch and main as the "base" branch
- Fill in the PR description with details about your changes
- Click "Create pull request"
- Respond to feedback and make additional commits if needed:
$ git add .$ git commit -m "Address feedback: fix X"$ git pushThese commits will automatically appear in your open PR.
- Merge the PR once it's approved (typically done on GitHub)
- Delete your branch after it's merged (can be done on GitHub or locally)
- Sync your local repository with the updated main branch:
$ git checkout main$ git pull origin main
The Fork and Pull Request Workflow
For contributing to open-source projects or repositories where you don't have direct write access:
- Fork the repository:
- Navigate to the original repository on GitHub
- Click the "Fork" button in the top-right
- This creates a copy of the repository under your GitHub account
- Clone your fork locally:
$ git clone git@github.com:your-username/repository-name.git - Add the original repository as "upstream":
$ git remote add upstream git@github.com:original-owner/repository-name.git - Create a branch for your changes:
$ git checkout -b feature-name - Make your changes, commit them, and push to your fork:
$ git add .$ git commit -m "Implement feature X"$ git push -u origin feature-name - Create a Pull Request from your fork to the original repository:
- Navigate to your fork on GitHub
- Click "Pull requests" and then "New pull request"
- The page will compare across forks, with the original repository's main branch as the base
- Select your feature branch as the "compare" branch
- Click "Create pull request"
- Fill in a detailed description and click "Create pull request" again
- Wait for feedback and make updates if needed
- Keep your fork updated with the original repository:
$ git checkout main$ git fetch upstream$ git merge upstream/main$ git push origin main
Handling Pull Request Feedback
When you receive feedback on your Pull Request, you may need to make changes:
- Checkout your feature branch if you're not already on it:
$ git checkout feature-name - Make the requested changes
- Commit and push your changes:
$ git add .$ git commit -m "Address PR feedback: fix X"$ git push - The PR will automatically update with your new commits
- Respond to the feedback comments on GitHub to notify reviewers that you've made changes
Essential GitHub Features for Collaboration
Pull Requests: More Than Merging Code
Pull Requests (PRs) are the heart of collaboration on GitHub. They provide a forum to discuss proposed changes before they're integrated into the main project.
Key PR features:
- Code review: Reviewers can comment on specific lines of code
- Discussion threads: Have conversations about implementation details
- Approval workflow: Require approvals before merging
- CI integration: Automatic testing of proposed changes
- Draft PRs: Signal that work is in progress and not ready for review
PR best practices:
- Keep PRs focused on a single logical change
- Write clear descriptions explaining what, why, and how
- Reference related issues with # notation (e.g., "Fixes #123")
- Respond promptly to feedback
- Use the "Files changed" tab to review your own changes before requesting reviews
Issues: Tracking Work and Bugs
GitHub Issues are a lightweight way to track todos, bugs, feature requests, and more.
Issue features:
- Labels: Categorize issues (bug, enhancement, documentation, etc.)
- Assignments: Designate who's responsible for an issue
- Milestones: Group issues into deliverable units
- Templates: Standardize how issues are reported
- Mentions: Notify team members with @username
Issue best practices:
- Be specific about what needs to be done
- Include steps to reproduce for bugs
- Close issues automatically from PRs by using keywords (e.g., "Closes #123")
- Use issues to discuss ideas before implementation
GitHub README Files: Your Project's Front Page
The README.md file is often the first thing people see when they visit your repository. A good README is crucial for making a positive impression and helping others understand your project.
README essentials:
- Project name and description: What does your project do?
- Installation instructions: How to get your project running
- Usage examples: How to use your project
- Documentation: Where to find more detailed information
- Contributing guidelines: How others can help
- License information: How your code can be used
README files use Markdown formatting, which allows you to include headings, lists, code blocks, links, and images.
GitHub Actions: Automation for Your Repository
GitHub Actions allow you to automate workflows directly from your repository.
Common use cases:
- Continuous Integration (CI): Automatically run tests when code is pushed
- Continuous Deployment (CD): Automatically deploy when changes reach main
- Code quality checks: Run linters, formatters, and security scans
- Issue management: Automatically label issues, assign reviewers, etc.
While GitHub Actions are more advanced, they're worth knowing about as you grow your development skills.
Hands-on Practice: Working with GitHub
Let's practice the GitHub workflow with our Python Todo application from the previous session.
Exercise 1: Create a Remote Repository
- Create a new repository on GitHub:
- Name: "python_todo_app"
- Description: "A simple command-line todo application built with Python"
- Visibility: Public (so you can share your work)
- Don't initialize with README, .gitignore, or license (since we're connecting an existing repository)
- Connect your local repository:
$ cd ~/path/to/python_todo_app$ git remote add origin git@github.com:your-username/python_todo_app.git - Push your code to GitHub:
$ git push -u origin main - Verify on GitHub that your code has been uploaded
Exercise 2: Enhance Your Project's Documentation
- Improve your README.md file:
# Python Todo Application A command-line todo application built with Python. This app allows users to add, view, complete, and manage todo items with features like due dates and priorities. ## Features - Add and list todo items - Mark items as completed - Set due dates and priorities - Save todos to a file for persistence - Simple and intuitive command-line interface ## Installation 1. Clone this repository: ``` git clone https://github.com/your-username/python_todo_app.git cd python_todo_app ``` 2. No additional dependencies required! The app uses only Python standard library. ## Usage Run the application with: ``` python todo.py ``` ### Available Commands - `list` - Show all todo items - `add [text]` - Add a new todo item - `add [text] @YYYY-MM-DD` - Add todo with due date - `add [text] !high/!medium/!low` - Add with priority - `complete [num]` - Mark an item as completed - `save` - Save todos to file - `help` - Show help message - `quit` - Exit application (auto-saves) ## Example ``` $ python todo.py Welcome to the Todo App! Enter 'help' to see available commands. Enter command: add Buy groceries @tomorrow !high Added: Buy groceries (priority: high) (due: 2023-07-15) Enter command: add Schedule dentist appointment @2023-08-01 Added: Schedule dentist appointment (due: 2023-08-01) Enter command: list Todo List: 1. [ ] Buy groceries [!] (due: 2023-07-15) 2. [ ] Schedule dentist appointment (due: 2023-08-01) Enter command: complete 1 Completed: Buy groceries Enter command: list Todo List: 1. [✓] Buy groceries [!] (due: 2023-07-15) 2. [ ] Schedule dentist appointment (due: 2023-08-01) Enter command: quit Todos saved to file. Goodbye! ``` ## Contributing Contributions are welcome! Please feel free to submit a Pull Request. ## License This project is licensed under the MIT License - see the LICENSE file for details. - Create a LICENSE file:
$ touch LICENSEAdd the MIT License text (you can find this on GitHub when creating a new file named LICENSE)
- Commit and push these changes:
$ git add README.md LICENSE$ git commit -m "docs: Enhance project documentation with detailed README and license"$ git push
Exercise 3: Create a Feature Branch and Pull Request
- Create a new branch for adding a search feature:
$ git checkout -b feature/search-todos - Add the search functionality to todo.py:
# Add this new function def search_todos(query, todos): """Search todos for a specific query string.""" if not query: print("Please provide a search term.") return query = query.lower() results = [] for i, todo in enumerate(todos): if query in todo['text'].lower(): results.append((i, todo)) if not results: print(f"No todos found matching '{query}'") return print(f"\nSearch results for '{query}':") for i, todo in results: status = "✓" if todo["completed"] else " " priority = todo.get("priority", "normal") priority_marker = "" if priority == "high": priority_marker = " [!]" elif priority == "low": priority_marker = " [.]" due_info = f" (due: {todo['due_date']})" if todo.get("due_date") else "" print(f"{i+1}. [{status}] {todo['text']}{priority_marker}{due_info}") # Update main() function to include the new search command def main(): todos = load_todos() print("Welcome to the Todo App!") print("Enter 'help' to see available commands.") while True: command = input("\nEnter command: ").strip().lower() if command == 'quit' or command == 'exit': save_todos(todos) print("Goodbye!") break elif command == 'help': print_help() elif command == 'list': list_todos(todos) elif command.startswith('add '): add_todo(command[4:], todos) elif command.startswith('complete '): try: index = int(command[9:]) - 1 complete_todo(index, todos) except ValueError: print("Please provide a valid number.") elif command == 'save': save_todos(todos) elif command.startswith('search '): search_todos(command[7:], todos) else: print("Unknown command. Enter 'help' to see available commands.") # Update print_help() to include the search command def print_help(): """Display available commands.""" print("\nAvailable commands:") print(" list - Show all todo items") print(" add [text] - Add a new todo item") print(" add [text] @YYYY-MM-DD - Add todo with due date") print(" add [text] @today/@tomorrow/@nextweek - Add with relative due date") print(" add [text] !high/!medium/!low - Add with priority") print(" complete [num] - Mark an item as completed") print(" search [text] - Search todos for specific text") print(" save - Save todos to file") print(" help - Show this help message") print(" quit - Exit the application (auto-saves)") - Test the new feature to make sure it works
- Commit your changes:
$ git add todo.py$ git commit -m "feat: Add search functionality for finding todos by keyword" - Push your branch to GitHub:
$ git push -u origin feature/search-todos - Create a Pull Request on GitHub:
- Go to your repository on GitHub
- You should see a prompt to create a PR from your recently pushed branch
- Click "Compare & pull request"
- Fill in a descriptive title and description
- Click "Create pull request"
- Merge your own Pull Request:
- Since this is your repository, you can approve and merge your own PR
- Click "Merge pull request"
- Click "Confirm merge"
- Update your local main branch:
$ git checkout main$ git pull
Exercise 4: Clone and Contribute to a Classmate's Repository
Pair up with a classmate or find an open-source project to contribute to:
- Fork their repository on GitHub:
- Navigate to their repository
- Click the "Fork" button
- Clone your fork locally:
$ git clone git@github.com:your-username/their-repository.git$ cd their-repository - Add the original repository as "upstream":
$ git remote add upstream git@github.com:their-username/their-repository.git - Create a branch for your contribution:
$ git checkout -b feature/your-contribution - Make a meaningful change (add a feature, fix a bug, improve documentation)
- Commit and push your changes:
$ git add .$ git commit -m "feat: Add feature X"$ git push -u origin feature/your-contribution - Create a Pull Request from your fork to the original repository
- Wait for feedback and collaborate with the repository owner
Best Practices for GitHub and Remote Repositories
Repository Organization
- Keep repositories focused: Each repository should represent a single project or logical unit
- Use clear, descriptive names: Repository names should indicate what the project does
- Maintain good documentation: README, LICENSE, CONTRIBUTING.md files help others understand your project
- Pin important repositories: Pin your best or most active repositories to your GitHub profile
Commit and Push Practices
- Push regularly: Don't keep local changes for extended periods without backup
- Pull before you start working: Always start with the latest code
- Use meaningful commit messages: These become part of your project's documentation
- Keep commits atomic: Each commit should represent a single logical change
Branching Strategy
- Use feature branches: Never commit directly to main for significant changes
- Consider a git-flow approach: For larger projects, a structured branching model helps manage releases
- Keep branches short-lived: The longer a branch exists, the harder it becomes to merge
- Delete merged branches: Keep your repository clean
Collaboration Etiquette
- Communicate clearly: Write clear PR descriptions and issue reports
- Review code thoroughly: Take time to provide thoughtful feedback
- Be respectful: Remember that code reviews are about the code, not the person
- Follow project conventions: Adapt to the existing coding style and workflow
- Credit others: Acknowledge contributions and ideas from team members
Security Considerations
- Never commit sensitive data: API keys, passwords, tokens should be kept out of repositories
- Use SSH authentication: More secure than password authentication
- Enable two-factor authentication: Protect your GitHub account
- Review access permissions: Regularly audit who has access to your repositories
- Consider branch protection: Prevent force-pushes to important branches
Building Your Professional GitHub Profile
Your GitHub profile is becoming increasingly important in the tech industry. It serves as a portfolio of your work and a reflection of your coding abilities. Here's how to make yours stand out:
Profile README
GitHub allows you to create a special repository that displays content on your profile page. To set this up:
- Create a new repository with the same name as your GitHub username
- Add a README.md file to this repository
- This README will be displayed at the top of your profile page
Your profile README can include:
- A brief introduction and bio
- Skills and technologies you know
- Current projects or areas of interest
- How to contact you
- Fun facts or personal touches
Showcasing Your Best Work
- Pin repositories: Pin your most impressive or representative projects to the top of your profile
- Quality over quantity: A few well-documented, complete projects are better than many incomplete ones
- Diverse projects: Show range by including different types of projects (web, data, mobile, etc.)
- Consistent activity: Regular contributions show dedication and ongoing learning
Building a Contribution Graph
The contribution graph (the "green squares") on your profile shows your GitHub activity. To build a meaningful graph:
- Contribute regularly: Consistent activity is more impressive than sporadic bursts
- Contribute to open source: Help existing projects by fixing bugs or adding features
- Document your learning: Create repositories for courses or learning projects
- Write technical content: Share tutorials or solutions to problems you've solved
Collaboration and Networking
- Follow interesting developers: Learn from others in your field
- Star useful repositories: Build a curated list of resources
- Engage in discussions: Comment on issues and pull requests
- Join organizations: Participate in coding communities or hackathons
Key Takeaways
- Remote repositories extend Git's power: They enable collaboration, backup, and sharing of your code
- GitHub provides a social layer: Issues, Pull Requests, and other features facilitate teamwork
- Proper workflows are essential: Following established patterns makes collaboration smoother
- Documentation matters: READMEs and other docs help others understand and use your code
- Your GitHub profile is your portfolio: Invest time in making it representative of your skills
As you continue your journey as a developer, GitHub will likely become an everyday tool in your workflow. The skills you've learned today form the foundation for effective collaboration and project management in modern software development.
Assignment: GitHub Repository with README
Create a GitHub repository that effectively showcases your goals for this Python Full Stack Developer course.
Requirements
- Create a new GitHub repository:
- Name: "python_fullstack_course"
- Description: "My journey learning Python Full Stack Development"
- Visibility: Public (so it can be part of your portfolio)
- Initialize with a README.md
- Enhance the README.md with:
- Your name and background
- Why you're taking this course
- Your goals for the next 14 weeks
- Any previous experience with Python or web development
- Technologies you're excited to learn
- Projects you hope to build
- How you plan to apply your new skills after the course
- Add structure to the repository:
- Create folders for different weeks or topics
- Add a sample Python file demonstrating a basic concept
- Include a .gitignore file appropriate for Python projects
- Make at least 3 separate commits:
- Initial commit with README
- Add directory structure
- Add sample code and .gitignore
- Use Markdown formatting in your README:
- Headings and subheadings
- Lists (ordered and unordered)
- Code blocks for any code snippets
- Bold and italic text for emphasis
- Optional: Add a link to your personal website or LinkedIn
Submission
Submit the URL to your GitHub repository. Make sure it's public so it can be viewed for grading.
Bonus Challenges
- Create a GitHub Profile README to showcase your professional information
- Add a licensing file to your repository
- Create a simple GitHub Pages site for your repository
- Add a badge or status indicator to your README
Additional Resources
GitHub Documentation and Guides
- GitHub Docs - Official documentation
- GitHub Guides - Including "Hello World" and "Mastering Markdown"
- GitHub Learning Lab - Interactive tutorials
Git and GitHub Cheat Sheets
Markdown
- Markdown Guide - Comprehensive reference
- Dillinger - Online Markdown editor
GitHub Profile Enhancement
- Awesome GitHub Profile READMEs - Inspiration for your profile
- GitHub Profile README Generator
GitHub Best Practices
- Project Guidelines - Best practices for Git/GitHub
- Conventional Commits - A specification for commit messages