Forem: adikejre

Working collaboratively with git

adikejre — Fri, 07 Apr 2023 12:14:21 +0000

Git is very useful when working with other developers. It helps keep track of changes, allows you to undo mistakes, integrate changes from other developers and work together as a team.
For example:
You and your friend are working on a project collaboratively and making changes, writing, rewriting and editing
As you both are working on different parts of a file and constantly editing, it would be preferable to track the changes instead of manually keeping all the versions of the file in your system (like project_part1, project_final, project_final2… it gets really messy and it gets easy to lose track)
Add another person and their changes to the equation it gets worse to manage. In this post you will see a workflow on how 2 developers can use git to work collaboratively.
For a basic introduction to git, checkout my previous post.

Initial Setup

We can start with creating an empty repository in Github and cloning it to our machine as below.

In the base directory we create an HTML file with some content to get started with and commit and push the changes to Github.

We can now create a branch to work on for our changes as shown following so that we dont push unecessary changes to the the main branch.

We use the commands git branch <branch_name> and git checkout <branch_name>as shown below.

We can see the test1 branch in github with our changes and an option for raising a pull request which we will see shortly

Developer 2 adding changes

Now as your friend wants to contribute to the project, they can clone the project to their system, create a new branch test2 from main and start working on their changes

They add the following changes to the <style> in the html file and commit and push the changes to the test2 branch.

Creating Pull Request

The changes made by the two developers now exists in their respective branches. They want to add their changes to the main branch so that both of their changes are 'merged' .
To do that a pull request is created which is a merge request to add your changes to the main branch.

Pull Request from test1 branch

For the first pull request, we want to merge changes from test1 branch to the main branch. We compare the changes as following a create a pull request for the content changes:

On creating the pull request, we can see there are no merge conflicts and the branch can be merged into main.

And now in the main branch we see the changes getting reflected!

Pull Request from test2 branch

Similarly we create a pull request from test2 to main for the styling changes.

The branch can be merged as there are no conflicts and we merge pull request.

And now we see in our main branch, the changes from both the branches is reflected!

Now if we want to continue working on our test1 branch and pull the latest changes from main, we can do it painlessly with the git pull command as shown below.

This is how we can work collaboratively with git. It scales really well when working on projects in large teams and is a really powerful tool for ensuring mistakes are minimized and all changes are appropriately reviewed before merging. Thus, following this simple workflow can make it very easy to work collaboratively and definitely will make you want to consider using this in your next project!

Git Demystified

adikejre — Wed, 05 Apr 2023 17:23:51 +0000

Git can seem to be an intimidating tool to use and especially for those starting out, it is easy to get lost in the complexities and the vast use cases which might lead you to wonder- Is it worth the headache?
In this blog, I will attempt to show a simple workflow on how to use git in a simplified way and cover basic commands and use cases. This will help in getting comfortable with using git and github and cover basic commands to get started with.

What is Git?

Git is a version control system which lets you to track all the changes made to a file system.
A repository is created and initialized which contains all the files. Git maintains a history of all changes made to these files over time. This allows you to view the changes made to the code, collaborate with other developers, revert to previous versions and essentially time travel between the different versions of the code base.

Creating a Github Repository

We can easily create a repository as shown below.

Once it is created, we can clone the repository on our local machine so that we can easily make changes in our files. For this we use the command: git clone

We copy the https key and do git clone as shown below using powershell

Great! so now we have created an empty repository and cloned that on our local system. You can see the .git folder present in the project's root directory.

Now we can start adding files and making changes.

Making changes and pushing the code

Now in the directory where we have cloned, we can create a sample html file and add content.

Now we need to accomplish the following:

Add all our changes to the working tree so that we can push it
Commit our changes to record all the changes we have made
Push our changes to github

For this we use the following commands:

git add -A : This adds all our changes made in our directory
git commit -m "commit message" : This records the changes and adds a comment to the commit.
git status : To see all the changes which are staged but not yet pushed
git push : This uploads the changes to the remote repository which is in github

These commands are seen below in action:

And here instantly we can see the file we created and all the changes reflected on our github repository.

Git Branches

Creating separate branches to work on is very useful especially when working on different features which you want to keep separated. It is good practice to work on a branch instead of the main so that the main or master branch is protected and changes are only made to the required branch.

The following commands are used:

git branch <branch_name> : Creates a new branch with given name
git branch : Gives the name of the current branch
git checkout <branch_name> : Shifts to the given branch

Thus it is easy to switch between branches and using different branches for different features is often useful.

We create a branch test1 and push the changes to it.

Note that when pushing to a new branch which does not have an upstream branch in github yet, we use git push --set-upstream origin test1

Now a friend wants to contribute to your project. This is easy to do as they can clone the repository in their system and create a branch and start working on their own.

As shown above, the repository is cloned and test2 branch is created to work on.

This covers the basics of setting up a git project, and a workflow on the basics of git you need as a developer working on your personal project and wants to start with simple version control to make life easier. In the next posts, I will go into more detail on how to work collaboratively using git, make pull requests and cover other useful commands.