How To Upload A Project To Github With A Group

Using Git and Github on Group Projects

Working on group projects for the first time tin be very intimidating if you are not very familiar with git commands and how it works. However, if you follow the process you will minimize merge conflicts and have a much smoother time working with others on a projection. My examples will use Github simply the git commands will exist the aforementioned for other version command hosting sites.

And then what is git? Simply put it is a version control system used for tracking changes during software development. Information technology is incredibly powerful tool but just if you empathize it. In that location are many ways that you could handle multiple project members code contributions but this mode is what I take used so far with several projects and have avoided any serious merge bug or code loss.

It is important to familiarize yourself with the post-obit diagram. This is the basic structure of how to ensure that each group member is working on as up to date code every bit possible. My personal preference for working with others who are not familiar is to non make them collaborators on Github. This prevents them from accidentally pushing up out of engagement lawmaking straight to the master repository. The only main departure if you exercise brand everyone a collaborator is each member will exist able to button straight to the deject master instead of having to become to a fork and do a pull request.

The greenish boxes stand for the local machines that are each working on the project. The projection creator is the person who started the repository. They will get through a different process than other members but that person should be someone very familiar with the git process every bit they are going to act equally a gatekeeper for code changes. The blue boxes correspond cloud repositories of the project. The main repository is on the left and the fork is represented by the blueish box on the right.

Setting upward your remote

First the project creator needs to create a new repository online. With Github make certain you do not initialize with a README. You will desire a blank repo to import your initial piece of work into.

One time created, you will have access to a repo link url. In my case this is "https://github.com/AndrewMatheny/TestExample". At present the project creator needs to run a couple commands in their last within the main project folder.

          git remote add upstream https://github.com/AndrewMatheny/TestExample.git          git push -u upstream master

So "git remote add <remote name> <remote url>"

Then push your code up with the git push button command.

Now your code is available at your repository link. The other group members should navigate to the page and fork your repository. Later on forking they will need to clone down the repo to their local machine.

On their fork they will be able to clone downwardly the code from when information technology was originally forked.

One time cloned down make sure they blazon in "git remote -v". That command will testify their remote connections. They should have origin connections to their fork.

They should see something like this with their remote links.

Then if they use the commands from earlier they can connect up to the main project master.

          git remote add upstream https://github.com/AndrewMatheny/TestExample.git

This will add together the main repo so they can clone downwardly the most contempo master when they want to update their local main. At this betoken every team fellow member should have an origin remote which connects to their fork and an upstream remote which is connected to the master projection repo.

And then what do I practice when someone makes a alter?

Simply follow the steps if you are a team member and in that location should be no major merge conflicts unless you completely rewrite the project. Likewise daily reminder to never work in the master branch. Always make a new co-operative when you outset to do any changes to the code.

Before you start make certain yous have added and committed your changes on your evolution co-operative. If you are a team fellow member you will outset with C on the visual. The team member needs to clone downward the most contempo master to their local master.

"git pull upstream main"

Then they need to pull in their changes to their local chief branch.

"git merge <co-operative proper noun>" — Brand sure that co-operative has its changes committed.

If at that place is any merge conflicts yous tin deal with them locally. I personally employ Visual Studio Lawmaking and that program does a great job of helping to manage merge conflicts.

Then push button up your local master to your fork (origin). This is arrow D on the visual above.

"git push origin master"

Then simply create a pull asking from the team members fork and the project leader can accept the changes. There should be no merge problems equally we dealt with them locally kickoff.

"But what if I'1000 the projection leader?"

If you created the repository so you have less steps and it is almost exactly the same. First pull downwardly the almost contempo master in case anyone has pushed whatsoever changes. Pointer A on the visual.

"git pull upstream master" (this may be origin instead of upstream if yous did not rename it)

Then merge your committed changes with "git merge <branch name>". And so deal with any merge conflicts

Then following the visual (pointer B). "git push upstream master".

That pushes your changes up to the cloud master. Whenever anyone makes a change that could impact what other members are working on they should get to a stopping point and pull down the most recent changes. This will prevent y'all from resolving the same merge conflicts again and again.

Source: https://medium.com/@androidmatheny/using-git-and-github-on-group-projects-d636be2cdd4d

Posted by: rodriguezrawastrand.blogspot.com