Using GitHub for Teams by Michelle Mannering

What is Git?

Looking back at the history of Git, this distributed version control system was introduced in 2005 as a method of monitoring a project’s history and changes over time. Distributed version control systems differ from local control systems in that they enable anyone who is working on the project to have access to the same copy of a project file, including the same version and the same history. This distributed model makes Git a great tool for teams to work together and collaborate easily. 

Collaboration is not a new thing; people have been collaborating long before Git was introduced. Because teamwork and collaboration have been around for so long, researchers have been able to study and identify how to utilize them effectively.

Why is Teamwork Important?

The more we learn about how to foster individual, group, and even corporate success, the more we realize that collaboration and teamwork are vital to achieving goals. 

Recently, global circumstances have necessitated that we take those principles of effective teamwork and translate them into a digital environment. Remote work has become more and more common since the pandemic, and likely will continue to be a mainstay for many workplaces moving forward. Regardless of if you are working from home, in the office, on a huge team or small one, Git truly has something for everyone. 

Git & Communication

One of the key aspects of effective collaboration is communication. If teams don’t communicate well, they don’t work together well, and ultimately, that team won’t be able to deliver their products to their customers well.

“Coding is a team sport.”

Nat Friedman, GitHub CEO

Whether you’re more of a physical sport type person or an e-sports person, you’ll know that good teamwork is the key to victory. More often than not, the teams that work together well are the teams that communicate the best. It’s not uncommon for a team with mediocre skills but excellent communication to beat a team with top notch skills but poor communication.  

Let’s say your organization has an engineering team, a sales team, a community team, and a management team. If these teams want to be successful, they should work collaboratively within and across their organizations. If all these teams only fixated on their own little thing, the engineering team would go just build stuff because they can. The sales team would just go sell whatever they want, and it might not even be what the engineering team is building. The community people and the marketing people would go out making promises about the product that may or may not be true. Finally, a manager asks: “What in the world is going on?” – and all anybody knows is what’s happening in their own little bubble. 

Nobody wants that scenario to be their reality. To avoid this gridlocked mindset, each individual and team should learn to recognize the interdependent relationship that exists between departments. 

Imagine all these teams are now working together. Developers build really good products, marketing crafts an informed pitch, the community team is able to curate valuable ideas and input from users, sales is able to reach new markets, and the managers are really happy because everyone is making more money. This is the kind of compounding success that is fostered by communicative teams. 

If you want to get started now, tools like Slack, Microsoft Teams, GitHub for teams, Zoom, and more tools for remote dev teams help facilitate remote communication within your teams and company. However, don’t go out there and adopt a central communication tool and just assume that you’re now communicating effectively. Rather, focus on what you can do to foster a culture that values collaboration and teamwork and then use the communication tool as a resource.

Basic Git Flow & Git Commands

This image shows the flow of a project in Git using the GitHub flow model, one of the most recognized Git branching strategies. Across the top, you’ll find the main branch (shown here as “Master”). This represents the project that you’re currently working on. When you want to create a new feature for the project or a new version, you will create a Git branch. 

During this phase, you should be discussing the feature with your team and how it fits into the project at a high level. Once you and your team are happy with your Git branch, you can merge it back into the main branch. Usually, once you Git merge your feature branch back into the main branch, you will delete your local Git branch to keep the project clean.

There are a number of ways to view and alter a project’s Git history. One of the ways to do that is via Git commands. Git commands can be used to add files, add commit points, create messages for your files, and see the project history. Be aware that when you make changes to a project on the remote repository, everyone else with access to that repo can see those changes. This can be really helpful as it allows you and your team members to view what everyone else is doing in addition to the project’s overall status.

Git Commands

Getting Started with Git

Git init: turns the existing directory into a Git repository. 

Git clone: clones the Git repository to your local machine. 

Git config: configures things such as your username, email, and even the color of your commits on the CLI so you can easily distinguish what’s yours.

Git status: shows the status of a Git repo and the status of an overall project.

Changing a Git Repo

Git add: adds a file(s) to the repo containing changes ready to be committed. 

Git commit: commits the changes you’ve made 

Synching Commands

Git remote: allows you to create and delete connections to other repositories.

Git fetch: downloads all of your Git history from the remote repo to your local repo. 

Git checkout: allows you to switch to a particular branch.

Git pull: pulls in all the changes from the remote down to your local machine. 

Git push: pushes all the changes up to the remote. 

Working and Changing Versions

Git branch: Returns a list of all the branches currently in that repo. 

Git merge: allows you to merge changes back into the main.

Keeping a Clean Git History

When collaborating using Git, it’s important to keep things really tidy. One way to do this is by keeping a detailed commit history. When you commit regularly, you give yourself a good cushion for potential errors. It can be helpful to think of this process as creating “save points” for yourself each time you commit.

Creating save points is crucial to managing an effective workflow. When creating those points, be sure that they are specific, timely, and understandable. If you make an error and have been committing often, fixing the mistake is as easy as reverting to an older version, such as reverting a Git commit. 

Be specific and clear with your commits; you don’t want to end up with hundreds of random and unclear save points. 

In the image above, you can see what a Git log looks like in GitHub if you don’t use custom commit messages; it looks like an absolute mess. Having a bunch of files with the default file name: “Update whatever the file name is,” makes understanding what each commit represents virtually impossible. 

On the flip side, if you do take the time to include high quality custom commit messages, like shown in the image below, you add helpful context for you and your team as you’re viewing your project history in the future.

It’s easy to see the difference. This makes working on your project clearer and easier not only for you but for all of your team members. 

You might notice that some of the commit messages have ellipses next to them. This is a helpful way of noting that there’s even more information for that commit. This is just another practice that can help your team collaborate clearly and more effectively. 

At the end of the day, you decide which practices work best for you and your team. What’s most important is that you actually establish a set of standard practices, as well as a way to ensure each team member is following them. Teams that take the time to share ideas, come to a consensus, and keep one another accountable are able to work faster, more effectively, and ultimately build better products. 

If you’re looking to level up your team’s performance, look no further than GitKraken! GitKraken provides users with educational and Git training resources, improved visibility for teams using Git, and flexible license management. Teams that use GitKraken ultimately become more organized, efficient, collaborative, and successful using Git.