How To Change Github Repo Description

In this commodity, we shall briefly look at how we can submit work and contributions to a GitHub team project. This article assumes that yous have a GitHub business relationship. Check these instructions on how to create a GitHub user business relationship. Before nosotros get started, you need to sympathize the following terms, as you will constantly run across them in daily GitHub workflow.

Getting started

• Fork is a re-create of a repository of someone'due south else project. Forks allows you lot take to have a repository of a project that you do not ain on your GitHub account so that you tin brand some changes without affecting the original repository. Once the changes on your forked repository are validated, you can submit these changes as contributions to the original project. Forks allows you to brand your contributions to a team project.
• Remote a repository on GitHub account exists as a remote repository.
• Clone is downloading a copy of the remote repository to local reckoner.
• Commits are changes fabricated to a repository. Committing saves edits/changes to our GitHub repository. With GitHub, every commit you make has a specific signature/ID the keeps the tape of the changes you have fabricated. If you happen to make a wrong change, you can revert the commit and your remote repository will be as it was before you lot made the changes. A commit has a commit message that allows you to have a cursory clarification of the changes you are making.
• Button is used to transfer commits fabricated on a local repository to a GitHub remote repository. To push to GitHub you lot make a push request to update your local commits to your remote repository.
• Co-operative a characteristic branch or base of operations branch. A feature branch typically helps you lot to isolate your changes from the other team as you make and test these changes. The base of operations branch consists of merged feature branches.
• Pull request is to notify the project squad of the changes y'all accept made from a pushed co-operative in your GitHub repository or basically requesting the possessor of the repository to pull changes you fabricated, thus called a pull request. A collaborator can be assigned to review your pull and propose any potential changes you need to make. Review changes are done with commits. One time changes and reviews are complete a team correspondent or yous (with access), can merge your co-operative to the base branch of the original repository.
• Merge is merging two branches and integrating them into a single co-operative. A merge disharmonize can happen if the two branches you are attempting to merge take both modified the same part of the same file. In such a instance, Git will not be able to automatically choose which version to use.

How to fork

Now that you know, what a fork is, let's meet how you tin can fork a repository to start working on your changes and contribute to a squad projection. Forking a project on GitHub is really easy, you just demand to hit the fork button. On your GitHub account, become to the repository you lot want to fork. In this example, we are referring to https://github.com/section-io/engineering-education. To the upper left corner, click on the fork button and you will have successfully forked the repository.

Now you have a copy of the original repository on your GitHub account.

To start pushing, committing, and pulling, you need clone the repository you take forked (on your GitHub account) and a have copy on your computer to showtime working on your contributions.

How to clone

Cloning using GitHub desktop

If you are using the GitHub desktop app, cloning a repository is as piece of cake equally pie. To get started, download GitHub desktop and install it into your estimator and authenticate and configure it with your GitHub business relationship.

To make GitHub desktop piece of work easier, brand sure you configure GitHub desktop with a text editor such as Visual Studio Code.

Once that is washed, your GitHub account will load on the GitHub desktop. To kickoff cloning, navigate to File and so clone repository.

A clone window will popular upward, you lot will exist able to see the repositories in your account, and choose the repository you want to clone.

Alternatively, yous may use the URL from GitHub remote repository, paste on the clone box of GitHub desktop, and initiate cloning, select your preferred location of the cloned repository to your local computer and you are washed.

Cloning using Git Bash

Git uses protocols to transfer data from a remote server to your local car. The main used URL protocols include:

• SSH (Secure Shell) is an authenticated network protocol that needs credentials (a password) before making a connection to the hosting server. This is how a SSH link looks like:

            git://host.xz[:port]/path/to/repository.git                      

Example

            git@github.com:section-io/engineering-education.git                      

• HTTP/HTTPS (Hyper text transfer protocol). The protocol of the web, most usually used for transferring web folio HTML information over the Internet. Git tin can be configured to communicate over HTTPS with encoded data transmission.

            http[s]://host.xz[:port]/path/to/repository.git/                      

In this article, we shall use SSH URL protocol using Git Bash to execute git commands. However, to become started with Git Bash, yous demand to do the following authentication.

First, download and install git, launch Git Bash and sign in to your GitHub account using the following commands.

NOTE: retrieve to printing enter after whatsoever of the post-obit

            git config --global user.name              "your github account username"                      

            git config --global user.e-mail              "your github account email"                      

Run

            git config --global user.proper name                      

to confirm username and

            git config --global user.electronic mail                      

to ostend email. To connect to your GitHub account y'all demand to generate an SSH key. Run

            ssh-keygen -t rsa -C              "your github email"                      

Utilise the same email as your GitHub account email. After pressing enter on this command, you will be required to enter a password twice (this is not your GitHub countersign), enter any countersign of your choice, and when asked for confirmation renter the password once more. An SSH code will be generated and you need it to authenticate the protocol. To open the file created, run

            notepad ~/.ssh/id_rsa.pub                      

The file contains the SSH code, copy the central, and follow these instructions.

• On your GitHub account, go to settings
• Get to SSH and GPG keys
• Then new SSH cardinal
• Enter the championship "your key"
• Paste the copied SSH key in the big box
• Run command ssh -T git@github.com to check if the configuration is ok

This should give you the following bulletin Hi username! You've successfully authenticated, merely GitHub does not provide beat access. At present you are skilful to go with SSH protocol

To starting time our clone run git clone (SSH URL)

Example

            git clone git@github.com:kimkimani/engineering-education.git                      

Output

            Cloning into              'engineering-didactics'... Enter passphrase              for              central              '/c/Users/kim/.ssh/id_rsa': remote: Enumerating objects: 20,              washed. remote: Counting objects: 100%              (20/20),              done. remote: Compressing objects: 100%              (16/16),              done. remote: Total              9676              (delta 8), reused              xiv              (delta 4), pack-reused              9656              Receiving objects: 100%              (9676/9676), 108.32 MiB | 116.00 KiB/southward,              done. Resolving deltas: 100%              (5361/5361),              done. Updating files: 100%              (785/785),              done.                      

NOTE: make certain the link yous copy is SSH. And recollect to utilize the password you used when generating the SSH key to make hallmark for passphrase for fundamental '/c/Users/yous/.ssh/id_rsa\': If you do not enter the SSH password, you volition run into the following output Delight make sure you take the correct admission rights and the repository exists.

A re-create of the remote is now available on your local computer on the location you entered on the Git Bash command with the binder name the same as the name of the repository in the remote repository. In instance you desire to accept a different projection folder utilize the clone command followed by the name of your preferred folder.

            git clone git@github.com:section-io/engineering science-pedagogy.git folder-proper noun                      

When using a forked repo, the original repository will regularly be updated with commits. These commits are not directly updated to your repository, thus you lot demand to regularly update your fork to keep it up to appointment with the original repository.

Updating a fork using GitHub spider web UI

The process is elementary and articulate. Go to your forked repository in your GitHub account, you will see the number of commits that the original repository has, and have and non been updated to your forked repository.

Click compare.

Utilize switch to base of operations link.

If the switch to base is not available, use the dropdown to manually select the repositories to compare. When the comparing selections are correctly selected, y'all volition be able to see the commits that are not updated to your fork.

Go on to the light-green button and create a pull request.

Enter a title "updating my fork", comment as well, and continue to create a pull request.

Scroll to merge request.

Confirm merge.

And y'all are done, your fork is now updated successfully. The fork is updated on the remote and you lot now need to update the changes to your local repository. Go to your GitHub desktop and make sure your current repository you lot are working with is selected.

You will able to see a "pull origin". What this does is information technology pulls the remote changes to your local repository.

Click "pull origin" and your local repository will be updated and the same as the remote repository.

Summary

Updating a fork using Git Bash.

You take successfully forked your interested repository. However, you occasionally need to keep it upwardly to appointment with the original repository. The original repository is commonly referred to upstream by Git Fustigate command.

To update your fork with the upstream, you demand to get the remote to your local repository so that y'all can fetch available changes made in the original repository and push the changes to your local repository.

To go started navigate to your cloned repository (already on your local computer) and open the project folder with Git Bash or open Git Bash and alter the directory to betoken the cloned repository on your local storage. i.e.

            cd ~/Documents/GitHub/engineering-education                      

By default, your local repository is not directly linked to the original repository. Configure the remote upstream to be bachelor locally.

OUTPUT

            origin  git@github.com:kimkimani/engineering-education.git              (fetch)              origin  git@github.com:kimkimani/engineering-educational activity.git              (push)                      

At this point, only the original repository is linked (The remote repository that you forked from the original). Link your repository with the remote or the original repository.

            git remote add upstream <ssh url from the original repository> git remote add together upstream git@github.com:section-io/engineering science-education.git                      

Run

To confirm if your remote upstream is available on your local repository origin.
Output

            git@github.com:kimkimani/engineering-education.git              (fetch)              origin  git@github.com:kimkimani/engineering-education.git              (push button)              upstream        git@github.com:department-io/engineering-education.git              (fetch)              upstream        git@github.com:section-io/technology-education.git              (push button)                      

What you lot demand now is to fetch the changes/commits from the upstream

Output

            Enter passphrase              for              key              '/c/Users/kim/.ssh/id_rsa': remote: Enumerating objects: 139,              done. remote: Counting objects: 100%              (139/139),              done. remote: Compressing objects: 100%              (66/66),              washed. remote: Total              131              (delta 88), reused              105              (delta 65), pack-reused              0              Receiving objects: 100%              (131/131), 696.24 KiB | eleven.00 KiB/s,              done. Resolving deltas: 100%              (88/88), completed with              8              local objects.  *              [new branch]              EngEd-template-idea-form -> upstream/EngEd-template-idea-class  *              [new branch]              add-section-habitation       -> upstream/add-department-habitation  *              [new branch]              address-resolution-protocol -> upstream/address-resolution-protocol  *              [new branch]              authors-link           -> upstream/authors-link  *              [new branch]              clustering-algorithms  -> upstream/clustering-algorithms  *              [new co-operative]              documentation          -> upstream/documentation  *              [new co-operative]              fix-topic-capitalization -> upstream/gear up-topic-capitalization  *              [new branch]              fixing-blank-author-pages -> upstream/fixing-bare-author-pages  *              [new branch]              fourth                 -> upstream/quaternary  *              [new co-operative]              introduction-web-associates -> upstream/introduction-web-associates  *              [new branch]              knapsack               -> upstream/knapsack  *              [new branch]              make-author-pages-work -> upstream/brand-author-pages-work  *              [new branch]              man-in-the-middle-attack -> upstream/human being-in-the-middle-attack  *              [new branch]              master                 -> upstream/master  *              [new branch]              matplotlib-visualization-python -> upstream/matplotlib-visualization-python  *              [new branch]              nodejs-backend-frontend -> upstream/nodejs-backend-frontend  *              [new co-operative]              nodejs-cta-blocks      -> upstream/nodejs-cta-blocks  *              [new branch]              pr/54                  -> upstream/pr/54  *              [new co-operative]              private-cake-concatenation    -> upstream/private-block-chain  *              [new branch]              quality-checker-activity -> upstream/quality-checker-activeness  *              [new branch]              remove-articles        -> upstream/remove-manufactures  *              [new branch]              remove-unused-topic-pages -> upstream/remove-unused-topic-pages  *              [new branch]              site-mapping           -> upstream/site-mapping  *              [new branch]              supervised-motorcar-learning -> upstream/supervised-machine-learning  *              [new branch]              testing-author-page-blank -> upstream/testing-writer-folio-blank  *              [new branch]              vlan-trunking          -> upstream/vlan-trunking  *              [new branch]              vm-vs-containers       -> upstream/vm-vs-containers                      

You lot have fetched the changes, commits, and branches that you need to merge to the head branch. Before doing the merge, make sure you lot are updating this changes on your principal.

            git checkout upstream/master                      

Output

            Note: switching to              'upstream/master'. Y'all are in              'detached Caput'              land. You can look around, brand experimental changes and commit them, and you tin can discard any commits yous make in this land without impacting any branches by switching back to a branch. If yous want to create a new co-operative to retain commits you create, yous may              exercise              so              (now or later)              by using -c with the switch control.  Example:   git switch -c <new-branch-name>  Or undo this operation with:   git switch -  Plow off this advice past setting config variable advice.detachedHead to false HEAD is at present at              1335657              Merge pull request              #272 from kimkimani/virtually-useful-NodeJs-packages                      

OUTPUT fustigate Previous Head position was 1335657 Merge pull asking #272 from kimkimani/almost-useful-NodeJs-packages Switched to branch 'master' Your branch is upwardly to date with 'origin/master

This points to the branch you are already on, once on the principal branch, merge it with the upstream.

Output

            Updating d9acac5..646cb27 Fast-forrard  articles/huffman-coding-in-python/hero.jpg         | Bin              0              ->              27160              bytes  manufactures/huffman-coding-in-python/Code_Output.jpg  | Bin              0              ->              16932              bytes  articles/huffman-coding-in-python/alphabetize.md         |              185              ++++++++++++++  manufactures/huffman-coding-in-python/optimaltree.jpg  | Bin              0              ->              48468              bytes  .../stripe-integration-react/api_test_keys.jpg     | Bin              0              ->              160402              bytes  articles/stripe-integration-react/dashboard.jpg    | Bin              0              ->              147132              bytes  articles/stripe-integration-react/final_output.jpg | Bin              0              ->              90318              bytes  articles/stripe-integration-react/hero.jpg         | Bin              0              ->              30446              bytes  manufactures/stripe-integration-react/index.physician         |              281              +++++++++++++++++++++  articles/stripe-integration-react/paymentflow.jpg  | Bin              0              ->              71723              bytes  manufactures/stripe-integration-react/paywithcard.jpg  | Bin              0              ->              65169              bytes              xi              files changed,              466              insertions(+)              create way              100644              articles/huffman-coding-in-python/Code_Output.jpg  create mode              100644              articles/huffman-coding-in-python/hero.jpg  create mode              100644              articles/huffman-coding-in-python/alphabetize.doctor  create style              100644              manufactures/huffman-coding-in-python/optimaltree.jpg  create mode              100644              articles/stripe-integration-react/api_test_keys.jpg  create mode              100644              articles/stripe-integration-react/dashboard.jpg  create fashion              100644              articles/stripe-integration-react/final_output.jpg  create way              100644              manufactures/stripe-integration-react/hero.jpg  create manner              100644              articles/stripe-integration-react/alphabetize.physician  create fashion              100644              articles/stripe-integration-react/paymentflow.jpg  create way              100644              manufactures/stripe-integration-react/paywithcard.jpg                      

If the upstream and master have no changes to merge , Already upwardly to engagement. message will exist printed on your Git Bash. These changes are committed to your local repository,

Output

            Switched to branch              'primary'              Your branch is alee of              'origin/principal'              by              25              commits.              (use              "git push"              to publish your local commits)                      

Push these commits to publish them to your remote repository.

And yous are done. Refresh your remote repository, information technology will be upwards to engagement with the upstream.

We have forked, cloned, our repository is up to date, plus we are ready to piece of work on our contributions. Before you lot submit your contributions, make sure yous work on your changes and your content is well formatted gear up to make a pull asking.

Submit contributions using GitHub desktop

For convenience, open GitHub and open the repository with your preferred text editor.

If you are using Visual Studio Code, your cloned folder should look like to this

Since we are trying to make our contributions to Department, navigate to the manufactures folder.

Create a folder to work with.

Add together your contributions (i.e. index.md, hero paradigm, and other media where necessary).

When you are done calculation all your content, yous now need to commit the changes to your remote GitHub repository. Launch your GitHub desktop and you will be able to see the changes you have added.

It is now elementary from here, create a co-operative that volition have your changes.

Since we accept our changes ready, we need to merge these changes to the branch we have created. i.due east. "the changes on your folder and your piece of work in progress volition follow to the new co-operative" and click switch to branch.

Publish the co-operative to your remote GitHub account and make sure yous add together a commit message equally the summary.

Your branch content is on your remote GitHub repository, and you need to create a pull request to the origin repository to contribute your changes.

The create a pull request button will redirect y'all to your GitHub account where yous at present demand to create a pull asking. Make sure your title is relevant to the content you lot want to publish. Write a comment in the comment box with brief details of your content.

Once the pull request button is hit, you lot are done, you lot have submitted your contributions successfully.

Wait for your content to be reviewed and if any farther changes are needed, a comment will be left by the reviewer suggesting possible changes you should make nether your pull. Brand your edits on your text editor and make a commit to update the changes and recall to have a summary of the commit you are making for better referencing.

Submit contributions using Git fustigate.

Since you have a clone available on your local figurer, outset working on you contributions using a text editor. Format your content co-ordinate to the guidelines of the original repository.

Once you are washed and gear up to publish the content, it is advisable to push your changes under a branch and not to the master repository. This will help you lot to work and contribute changes nether different topics without co-operative or merge conflicts.

When the content (topic) is ready, create a branch and make sure you checkout on the branch as it will agree all your changes you are working on. Open up GitHub local directory on Git Bash.

If you run

OUTPUT

All the branches you lot have created will exist printed, in this case we take master branch, which is the electric current checkout. Create a new branch, with the name relevant to the topic or the content you want to button.

            git branch <branch proper name> git branch my-beginning-contributions                      

The new branch has been created. To ostend if the new branch was really created, run

OUTPUT

            * master   my-first-contributions                      

Checkout the new branch you lot have created

            git checkout <branch proper name> git checkout my-first-contributions                      

OUTPUT

            Switched to co-operative              'my-first-contributions'                      

All the bachelor changes that yous accept fabricated will be directed to the branch on the checkout. To bank check the changes you lot have created/modified run

OUTPUT

            On branch my-first-contributions Untracked files:              (use              "git add <file>..."              to include in what will be committed)              articles/new-folder-name/ nothing added to commit merely untracked files present              (use              "git add"              to rails)                      

These changes are bachelor on the local repository, and you need to make them ready to be pushed to your remote. To do this, run

            git add .              (make sure the fullstop after git add is included)                      

Run to confirm the changes are prepare.

git status

            On branch my-first-contributions Changes to be committed:              (employ              "git restore --staged <file>..."              to unstage)              new file:   articles/new-binder-name/hero.jpg         new file:   articles/new-folder-name/alphabetize.md                      

Your file changes volition be highlighted green, meaning set up to be published to remote. These changes are set to be committed

            git commit -m              "my first contribution"                      

                          [my-start-contributions 6b5e391]              my first contribution              ii              files changed,              one              insertion(+)              create mode              100644              manufactures/new-folder-proper name/hero.jpg  create mode              100644              articles/new-folder-name/index.                      

Push to the branch

            git push button origin my-first-contributions                      

Your content is now on your remote forked repository. To share your contributions to the team, y'all need to make a pull asking. Become to your GitHub account, under your forked repository.

Click the compare and pull asking push button.

And you are washed. Look for your content to be reviewed, make changes where necessary and your pull request will be merged to the team projection.

Note: every time y'all are making new contributions, ensure your remote fork and the local repository are upwards to date.

Conclusion

The outputs highlighted on this article may not directly lucifer to what will be printed to your Git Fustigate as that depend on the commits already published when making a clone or updating a clone equally well as the file changes you have made.

References

GitHub with SSH

GitHub authentifications

How to clone GitHub repository

Using Git

Issues and pull requests

Troubleshoot SSH

GitHub workflow management

GitHub desktop

Best Text Editors

---

Peer Review Contributions by: Nadiv Gilt Edelstein

Source: https://www.section.io/engineering-education/how-to-sync-and-update-a-forked-repo/

Share this post