A Complete Guide to GitHub Forks: From Setup to Pull Requests

GitHub is an essential platform for developers collaborating on code projects. One powerful feature is the fork. A fork is a copy of a repository. It lets you change and test code without affecting the original. In this article, we will guide you on how to use forks on GitHub. We will cover how to create a fork, keep it updated, and suggest changes to the original project.

What is a GitHub Fork?

A fork is a duplicate of an existing repository that you can modify independently. Forks are commonly used for:

• Open-source contributions: Proposing changes to a project you don’t own.
• Personal experimentation: Trying out new ideas without affecting the original project.
• Customizing code: Using someone else’s code as a foundation for your own project.

Forking lets you work on a project’s code without restrictions. You can then suggest changes to the original repository using pull requests.

GitHub Fork vs. Branch

Before diving into the details, let’s clarify the difference between a fork and a branch:

• A branch is a separate line of development within the same repository. It’s used when you have write access to a repository and want to work on changes without modifying the main branch.
• A fork is a copy of an entire repository in your GitHub account. It is usually used when you cannot access the original repository. However, you still want to contribute or experiment on your own.

If you don’t have write access to a repository, a fork is the best option. If you’re a collaborator with write permissions, a branch within the original repository might be simpler.

How to Fork a Repository on GitHub

Forking a repository is straightforward. Here’s how:

1. Open the Repository: Go to the GitHub repository you want to fork.
2. Click Fork: In the upper-right corner of the repository page, click Fork.
3. Select Owner: Choose your GitHub account or an organization to fork the repository to.
4. Rename and Describe (Optional): You can change the fork’s name and description if needed.
5. Copy Branches (Optional): By default, only the main branch is copied. Depending on your needs, you can choose to include all branches.
6. Create Fork: Click Create Fork, and GitHub will set up a copy of the repository in your account.

Your forked repository is now ready for you to modify without affecting the original project.

Making Changes and Proposing Pull Requests

Once your fork is ready, you can start making changes. To contribute these changes back to the original project, you’ll need to submit a pull request.

Step-by-Step Guide to Submitting a Pull Request

1. Clone Your Fork Locally:
   1. Open the forked repository on GitHub.
   2. Click Code and copy the repository URL.
   3. In your terminal, run:
      

git clone <repository_url>

4. Replace <repository_url> with your fork’s URL.
5. Create a New Branch for Your Changes:
   1. It’s good practice to create a branch for each feature or fix:
      

git checkout -b new-feature-branch

3. Make and Commit Your Changes:
   1. Edit the code, add files, or make adjustments as needed.
   2. Stage and commit your changes:
      

git add .git commit -m “Add a new feature”

4. Push the Branch to Your Fork:
   1. Push your changes to your forked repository:
      

git push origin new-feature-branch

5. Create a Pull Request:
   1. Go to your forked repository on GitHub.
   2. Click Pull Requests > New Pull Request.
   3. Choose the original repository as the base and your fork as the compare branch.
   4. Submit your pull request with a detailed description of your changes.

After submitting, maintainers of the original repository can review your changes and decide whether to merge them.

Syncing Fork with Upstream GitHub Repository

Keeping your fork updated with the original repository is important. This helps you stay current with recent changes. Here’s how to do it:

1. Add the Upstream Repository:
   1. Navigate to your cloned fork in the terminal.
   2. Add the upstream repository URL:
      

git remote add upstream https://github.com/ORIGINAL-OWNER/ORIGINAL-REPO.git

2. Fetch Upstream Changes:
   1. Fetch any updates from the upstream repository:
      

git fetch upstream

3. Merge Updates:
   1. Switch to your main branch:
      

git checkout main

2. Merge the upstream changes into your branch:
   

git merge upstream/main

4. Push Updates to Your Fork:
   1. Push the merged changes to your GitHub fork:
      

git push origin main

Regular syncing keeps your forked repository up to date with the original project. This reduces conflicts when you make your own updates.

Using Git Commands to Track and Review Changes

To maintain an organized history of changes in your fork, you can use Git commands to check commit logs and updates. Here are some essential commands for tracking and reviewing your changes.

1. Viewing Commit History with Git Log

The git log command displays a record of commits in your repository, showing details about each change. It’s useful for reviewing the history of changes made in your fork:

git log

You can add options like –oneline to simplify the output and view each commit as a single line:

git log –oneline

2. Listing Commits with Git List

The git rev-list command, often referred to as Git List Commits, allows you to list all commits in a branch or filter them by specific criteria. For example:

git rev-list HEAD

This command shows the complete commit history in the current branch. It’s especially helpful for reviewing updates or tracking progress before pushing changes to your GitHub fork.

3. Checking Changes with Git Diff

To view changes made since your last commit, use git diff. This is helpful for double-checking your modifications before committing or pushing them:

git diff

By using these commands, you can effectively track, manage, and review the history and details of changes in your forked repository, ensuring an organized and transparent development process.

GitHub Squash Commits: Clean Up History Before Submission

If you made several small commits while working on a feature, it can be helpful to combine them into one commit. Do this before you submit a pull request. This creates a cleaner, more manageable history.

How to Squash Commits

1. Rebase Your Branch:
   1. Use interactive rebase to squash commits:
      

git rebase -i HEAD~N

2. Replace N with the number of commits you want to squash.

2. Mark Commits to Squash:
   1. Mark all but the first commit as squash in the rebase editor.
   2. Save and close the editor to complete the rebase.
3. Push Squashed Commit to Your Fork:
   1. Push the squashed commit, possibly with a –force flag:
      

git push origin branch-name –force

Squashing commits is a good practice that makes your pull request easier to review and keeps the project’s history cleaner.

Conclusion

Using GitHub forks effectively can significantly enhance your development workflow. By understanding the full lifecycle of a fork, you can contribute to projects effectively. This includes creating the fork, making changes, syncing with the upstream repository, and submitting a pull request. This approach helps you keep a clean and organized history.

These practices are especially useful when working on open-source projects or collaborating with other developers on GitHub. With these skills, you’ll be well-equipped to participate in the GitHub ecosystem, whether you’re contributing to others’ projects or managing forks for your own.

The post A Complete Guide to GitHub Forks: From Setup to Pull Requests appeared first on Gun.io.