Git In Action (Multiple Repositories)¶

So far, we've only been working with a single local repository. However, Git is most powerful when working with multiple repositories, especially when working with multiple people.

Remote Repository¶

Identifying the Problem¶

Let's say I had a project on my computer, and I wanted to share it with someone else. I could send them the files, but what if I wanted to work on the project with them? I could send them the files, and then they could send me the files back, but that would be a pain to manage.

Incorporating Git¶

What if we had a central repository that we could both access? That way, we could both work on the project, and we could both see the changes that the other person made.

This is where a remote repository comes in. A remote repository is a repository that is stored on a server, and can be accessed by multiple people. This allows multiple people to work on the same project, and see the changes that the other person made. We'll touch more about how we're actually syncing changes in Pushing and Pulling.

Cloning a Repository¶

Let's say we have a remote repository that we want to work on. We can clone the repository to our local machine, and then we can work on it locally.

git clone¶

To clone a repository, we can use the git clone command. This command takes in a URL to a remote repository, and then clones it to our local machine.

git clone https://github.com/frc2204/ramdocs

sequenceDiagram
    participant Local1
    participant Local2
    participant Remote
    Local1->>Remote: git clone
    Remote->>Local1: Repository
    Local2->>Remote: git clone
    Remote->>Local2: Repository

Pushing and Pulling¶

Now that we have a remote repository, we can push and pull changes to and from the repository. This allows us to sync changes between multiple people.

git push¶

To push changes to a remote repository, we can use the git push command. This command will take all the new commits that we have made, and push them to the remote repository.

sequenceDiagram
    participant Local
    participant Remote
    Local->>Remote: git clone
    Remote->>Local: Repository

    Local->>Remote: git push

Now let's see how this works at scale

sequenceDiagram
    participant Local1
    participant Remote
    participant Local2
    Local1->>Remote: git clone
    Remote->>Local1: Repository
    Local2->>Remote: git clone
    Remote->>Local2: Repository

    Local1->>Remote: git push

git pull¶

To pull changes from a remote repository, we can use the git pull command. This command will take all the new commits that have been pushed to the remote repository, and pull them to our local repository.

sequenceDiagram
    participant Local1
    participant Remote
    participant Local2
    Local1->>Remote: git clone
    Remote->>Local1: Repository
    Local2->>Remote: git clone
    Remote->>Local2: Repository

    Local1->>Remote: git push
    Local2->>Remote: git pull
    Remote->>Local2: Repository

git fetch¶

Fetches the new commits from the remote repository, but won't merge them into our local repository. This allows us to see the changes that have been made, but it doesn't change our local repository.

sequenceDiagram
    participant Local1
    participant Remote
    participant Local2
    Local1->>Remote: git clone
    Remote->>Local1: Repository
    Local2->>Remote: git clone
    Remote->>Local2: Repository

    Local1->>Remote: git push
    Local2->>Remote: git pull
    Remote-->>Local2: Repository

git merge¶

Merge the new commits into our local repository. This will change our local repository if no conflicts occur.

sequenceDiagram
    participant Local1
    participant Remote
    participant Local2
    Local1->>Remote: git clone
    Remote->>Local1: Repository
    Local2->>Remote: git clone
    Remote->>Local2: Repository

    Local1->>Remote: git push
    Local2->>Remote: git fetch
    Remote-->>+Local2: Repository
    Local2->>-Local2: git merge

Resolving Conflicts¶

When a conflict occurs, Git lets us know, and we'll have to go in and manually resolve the conflict.

When a conflict occurs, Git will mark the conflict in the file with <<<<<<< HEAD, =======, and >>>>>>> .... You'll need to delete these elements and decide what you want to keep.

Example

<<<<<<< HEAD
This is the code that you wrote
=======
This is the code that the other person wrote
>>>>>>> ...

In this example, you'll need to decide whether you want to keep the code that you wrote, or the code that the other person wrote. Or both! It's up to you.

Once you've resolved the conflict, you'll need to commit the changes.

Avoiding Conflicts¶

Conflicts are inevitable, but there are some things that you can do to avoid them.

Branching¶

With branching, you can create a new branch, and work on that branch. This allows you to work on a feature without affecting the main branch. Once you're done with the feature, you can merge the branch into the main branch.

git checkout¶

To create a new branch, we can use the git checkout command. This command will create a new branch, and switch to that branch.

git checkout -b feature-branch

gitGraph
    commit
    branch cool-feature
    checkout cool-feature
    commit
    checkout main
    checkout cool-feature
    commit
    checkout main
    merge cool-feature

The code you change should only affect the feature you're working on, and not the main branch. This way, code remains somewhat isolated, and conflicts are less likely to occur.

Communication¶

Proper communication can help avoid conflicts. If you're working on a feature, let your teammates know. This way, they can avoid working on the same feature, and avoid conflicts.

Code With Me¶

A feature within JetBrains IDEs, Code With Me allows you to collaborate with other people on the same project. This allows you to see what the other person is doing, and avoid conflicts. It's essentially the Google Docs of programming, but for whole projects.

Congratulations! You now know the basics of Git and collaboration!