Git Reviews

78 Ratings
<a href='https://www.trustradius.com/static/about-trustradius-scoring' target='_blank' rel='nofollow noopener'>trScore algorithm: Learn more.</a>
Score 9.3 out of 100

Do you work for this company? Learn how we help vendors

Overall Rating

Reviewer's Company Size

Last Updated

By Topic

Industry

Department

Experience

Job Type

Role

Reviews (1-25 of 36)

Companies can't remove reviews or game the system. Here's why.
June 28, 2021
Anonymous | TrustRadius Reviewer
Score 9 out of 10
Vetted Review
Verified User
Review Source
Git is used across the organization for version control of the code build. It helps us track our deployments and snapshots of various artifacts we develop. All kinds of programming languages and files are checked in to git via github. We also control the code migration between various environments using Git.
  • Pull requests to control what's checked in where
  • 2-step commit and push to enable cleaner check-in process
  • Personal forks to help developers with quick development and testing
  • I feel that code merging using command line is not very straightforward when there are conflicts
Git is well suited for code that can be versioned. It cannot be effectively used for auto-generated code files from tools. For instance, Git is well suited for any code that we build using languages such as Java, python, scala, node, etc. However, the java code generated from tools such as Talend are not very well tracked when we use Git.
Read this authenticated review
January 23, 2020
Josh Stapp | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git is being used as version control software to merge different sets of code together and keep a log we can look back on if problems occur. I don't think there is any real competitor to Git. It can also be used to try to track your commit level vs others.
  • Better merges than anything else.
  • Logging.
  • Still some confusing merge issues.
  • I would like to see a system IDEs can use that automatically notifies you if someone pushes.
In my opinion Git is always best suited for every version control and anything but the most simplistic of temporary code should be version controlled. It takes so little effort and can save your entire application. SVN was much worse at merging when I used that for a couple years.
There is a lot of documentation online but it's not like you can call someone to help you with Git issues. Sometimes merge conflicts can get nasty.
Read Josh Stapp's full review
January 20, 2020
Ray Smith | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git is currently being used for version control in our IT department. This allows us to not only keep various projects under source control, but also to work on many different features concurrently, and maintain many different versions of our software.
  • Git has a very small footprint and works seamlessly on all major platforms.
  • Git's branch management model is wonderful and simple, especially when compared to some other VCS tools I've used.
  • Git has no native GUI. This means that if you want a GUI you're reliant on third party software in addition to Git.
  • Git Repository configuration is done at the host level which makes it difficult to enforce certain requirements, like with Git hooks for example.
Git is well suited for any file based scenario where source control is required. We mostly use Git for managing software repositories, but it would also be well suited for document version control. Anything that requires the modification of files and the potential need to roll back to a previous version is a good candidate for Git. The one scenario that in my opinion breaks this rule is database version control. With databases, we manage changes to table structure, functions, stored procedures etc., but I have yet to see good implementation of this with Git.
Git has a great deal of documentation and it's very easy to figure out how to do what you need to do. That being said, Git has no customer support to speak of.
Read Ray Smith's full review
January 18, 2020
Nate Dillon | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
We use Git as source control for all our projects across our entire department. I know there are other departments in our organization that use it as well. I also use Git for all my personal projects and side projects. Git enables all of our developers to collaborate and contribute code to our projects simultaneously, preventing conflicts.
  • Source control
  • Collaboration
  • Difficult for people who aren't used to the command line (but there are apps for that).
  • Some specific situations where it's difficult to figure out the right way to do things.
Git is great for pretty much any coding project, whether working on a team or with a single developer. For teams, it enables multiple developers to contribute without getting in each other's way. Git also keeps a history of all code changes, which is why I would also recommend using it on projects with a single developer. The only real scenario where I would maybe not use it is when working with non-tech people. But even then, I might recommend getting them set up with a Git client app and teaching them how to use it.
I am not sure what the official Git support channels are like as I have never needed to use any official support. Because Git is so popular among all developers now, it is pretty easy to find the answer to almost any Git question with a quick Google search. I've never had trouble finding what I'm looking for.
Read Nate Dillon's full review
November 05, 2019
Balázs Kiss | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Since the beginning of the uni, I found out that professional companies use at least some kind of versioning system. Git proved to be one of the most robust and logical systems for that. Every single company I have worked for is, or was about to, use it on a daily basis for supporting bigger codebases. The supporting software makes Git even more useful and one of the core tools used for modern software development. This is the number one must-have for every software development job.
  • Codebase versioning
  • Synchronizing multiple programmers on the same codebase
  • Helps following changes in the codebase, and an easy tool for keeping a stable codebase at all times on local machine and common server
  • The .git folder sometimes can mess up a little. We had to reset some repos before because of unstable repository states
  • I feel like there is still room for improvement for a better code merging tool
  • CLI outputs sometimes are a bit hard to use, for instance, git log's output is quite ugly
For beginner programmers or new recruits in our team, I always recommend to learn how to use Git and integrate it into their projects. This tool is essential for every single software writing process, even if you are the only programmer in the team, or a part of a bigger group. Git is an absolute must. The only scenario where it might not be useful is when people cannot configure it properly and include some unnecessary big files in it.
Never really had any issue or trouble with this tool.
Read Balázs Kiss's full review
January 30, 2020
Suleman Ahmad | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
We use Git in our entire organization for our codebase versioning/management. We migrated from TortoiseSVN. We work in different teams so every team takes the branch from production/master and works in their own branch so that it should not affect any other's work.
  • Fastest Branches Switching, in fractions of seconds we can switch between branches.
  • Easy to pull/push code.
  • When some thing went wrong on production, we have to create the revert of the pervious commit, so after fixing the issue we need to revert it again so that the original changes can apply, some times a chain of reverts continue. :(
- Easy to clone the repos.
- Secure to keep all the previous history changes.
- Fast to switch between branches.
- Easy to manage the codebase when we are working in the team.
The support team is good.
Read Suleman Ahmad's full review
September 28, 2019
César Costas Carrera | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git is used across most of the organization, if not all of it. Git is a Version Control System, which means that allows you to "backup" and control who edited your files, providing its best value when it comes to plain text files, such as code.
  • Git is a distributed system. Usually adding the word "distributed" makes things very complex and messy, but not with Git, thanks to its branches and merge control.
  • It's insanely fast.
  • Merges sometimes will produce conflicts that are time-consuming but its resolution is trivial if you consider the history of changes.
Git is the best suitable tool whenever you need to backup your documents quickly. Even more so if you need to keep track of who made changes.

It is not suitable when you want to work in a "blocking" mode, meaning:
- blocking any other user from editing while another user is editing.
- setting editing permissions per file avoiding users to edit or read a specific file.
The documentation is more than necessary to understand and work with it. The community of users is huge, so the internet is full of references on how to solve any kind of situation. The software is so simple, that reproducing a situation in order to help someone takes no time.
Read César Costas Carrera's full review
October 05, 2019
Anonymous | TrustRadius Reviewer
Score 9 out of 10
Vetted Review
Verified User
Review Source
GIT is being used as a version control tool within our organization. Its been used to speed up the code deliveries to different environment and track the changes being deployed to the software product.

GIT being widely used tool has proven itself to be more stable and reliable for code management within organizations and vital for organizations who share their codes(Ex : Integration kits) with their customers IT teams.
  • Better tool for products having faster release cycles.
  • Feature branching is a vital feature available in GIT as it make sure that not all code is merged to the master branch unless its production ready.
  • Easy to use commands and speed in Git operations.
  • GIT Commands could be more natural and intuitive.
  • GIT should improve handling of files like exe, image, docs etc.
  • Code commits on multiple branches should be available.
GIT is good to be used for faster and high availability operations during code release cycle. Git provides a complete replica of the repository on the developer's local system which is why every developer will have complete repository available for quick access on his system and they can merge the specific branches that they have worked on back to the centralized repository.

The limitations with GIT are seen when checking in large files.
GIT is phenomenal in helping to achieve better code management and version control for our products.
GIT have certain limitations with handling large size files but for code files which are in text file format its operational efficiency is way ahead than any other tools.
Being a globally accepted tool GIT commands are quite popular within folks and hence it makes it easier to handle operations through its command line.
For Teams using JIRA its a must have tool as they have same parent organization and have great integration with each other.
Read this authenticated review
January 18, 2020
Anonymous | TrustRadius Reviewer
Score 6 out of 10
Vetted Review
Verified User
Review Source
Git is used mostly as a source version controlling system which allows developers to collaborate with one another. It helps teams to contribute to various projects by pushing code to GIT. It can be used for release versioning. It is helpful to know which version has been released in production and at what codebase.
  • Flexibility
  • Version history
  • Merge conflict
  • Amending commits in remote repo
Git is well suited for collaboration. It can be used for multi-branch repositories and managing branch-heavy workflows. Collaborating is easier in Git. The disadvantage of using Git is that it is less secure. If the project is open source then it is fine, but Git charges for having a secured repository. Meanwhile, it offers private repos for free tier licenses.
Git is an excellent tool for collaboration and release version control. It helps you to track what changes were made to the project to reduce debugging. It is easier to move files from your local repo to Git. With respect to security, it lacks some features. Data can be easily downloaded by other users if it is not private.
Read this authenticated review
December 19, 2019
Anonymous | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
It's widely used by our component owners to store all the libraries. The beauty about Git compared to others is that it stores snapshots instead of deltas, which makes it just much much faster and more reliable to store code within it. We have integrated Git with Gerrit which stores the whole organization's Git repos within it, thus making it more reliable and scalable.
  • Fast.
  • Robust.
  • This tool is just perfect.
It is well suited for scenarios wherein you need to manage a lot of code and multiple developers are working on the same repository. The whole point of using Git is that you can create branches, develop the code on it, push it up and again keep on doing this. If you are not creating 10 branches a day you are not using GIT well.
It's open source. Not valid in here.
Read this authenticated review
November 23, 2019
Anonymous | TrustRadius Reviewer
Score 9 out of 10
Vetted Review
Verified User
Review Source
Our whole company uses Git for code collaboration where a team can continuously develop features for the software. Also, it allows our peers to review the code and once necessary approvals are received, we can merge the code ensuring proper workflow is followed. Git gives us helpful insight regarding project progress, software security vulnerabilities.
  • It's a great version control system helps us to develop the software incrementally releasing stable versions.
  • Git gives proper reminders when ever the my peers requests code review approval.
  • Git can be easily integrated with other software like Slack, Developer workbenches like Web Storm, Visual Studio Code, etc.
  • Git commands are very intuitive, makes us to easily understand and get the work done.
  • Git gives us great insights on the project progress like the number of Pull Requests Raised, Closed Issues, etc.
  • Git gives an intuitive UI, so the user can operate through the web.
  • Git can still improve UI design.
  • Git can also embed some artificial intelligence, and suggest alternate ways to solve the problem when the code review happens.
  • Git can also suggest when the deadline for any reviews should be closed so it helps the developers in the team to finish that PR within time.
Git is an open-source tool suitable for both small as well as large teams. It's great software for code collaboration and version control. I can't think of any situation where it will be less appropriate.
Git is a great automated version control software, allows the team to develop the product, build and deploy on the cloud iteratively. It helps make product management tasks easier to maintain.
Read this authenticated review
January 16, 2019
Gabriel Samaroo | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
My organization uses Git for version control of our various codebases. It is used by the engineering and dev-ops teams. We use git because it reliably handles creating branches for various features and bug fixes, and provides an effective and trusted way to merge and release that code to our different environments.
  • Ability to create branches and merge those changes in - very cleanly and in an organized way. Other features such as cherry-picking and rolling back are extremely useful.
  • Diff-ing changes is a great utility for reviewing code and understanding the history of code changes.
  • Git makes working in teams on the same set of code very possible, compared to some of the alternatives like SVN.
  • There can be quite a number of commands once you get to the advanced features and functionality of Git. Takes time to master.
  • Doesn't handle static assets (ie: videos, images, etc.) well. Although in the recent years, new functionality has been introduced to address this.
  • Many different GUIs, many people (including myself) opt to just use the command-line.
Git is by far the best Source Control Management Tool I've used. I would recommend it to anyone, whether it's an individual working on their own project, a small start-up company, or a huge organization with thousands of developers. Maintaining code via source control is absolutely mandatory for all developers everywhere.
Read Gabriel Samaroo's full review
March 30, 2019
Nikolay Rogoshchenkov | TrustRadius Reviewer
Score 9 out of 10
Vetted Review
Verified User
Review Source
Git is one of the source code version control tools used at my organization. We are using Git (Gitlab) to store our source code across multiple repositories. We have a mainline development branch which all our new code is eventually pushed to after being code reviewed by their branch using pull requests.
  • Ability to create branches and merge those changes in.
  • Diff-ing changes.
  • Many different GUIs, many people.
  • Understanding Git has a little bit more of a learning curve when compared to other source control solutions.
Developers can work parallel on projects, increasing the speed at which teams can work, thus causing projects to complete faster. Git has saved our organization hours of having to manually trace code to a breaking change or manage conflicting changes.
Read Nikolay Rogoshchenkov's full review
November 29, 2018
Joel Tanzi | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Our organization uses Git for code versioning, namely to track and manage changes to the codebase in a way that avoids accidentally writing over another engineer's code, resolves change conflicts, and provides a rollback option in the event of a breaking change. Git has become an important part of the development workflow for most software engineering teams. The problem Git addresses for us is the problem of having multiple people updating a codebase. One developer might change a portion of the code in one area and another might change it somewhere else, and managing the merging of these changes together is the main job of Git. To facilitate this Git stores every committed change in a log, and this log can be reviewed and even used to roll the code back and reject changes further down the pipeline. In our organization, each engineer creates a new branch from the master codebase whenever they are starting a new task in the project, and once they have completed that task and confirmed the code is stable, the code can be merged into the master codebase and eventually included in the production build. Our team has a strict policy of not merging your own code, so the code is reviewed and approved by another engineer whom merges it in after assessing its impact. We use Git across our engineering department only.
  • Git manages the merging of changes from different team members and provides for a way to roll back those changes when necessary.
  • Git allows for management of multiple branches of a code project and merging them in through a controlled and considered manner.
  • Git provides a complete history of all code changes and who made them, making the process of identifying when breaking code came in a much easier one along with identifying the code to roll back to (when needed).
  • Git is a powerful tool for change management and avoiding breaking code making its way into production.
  • Git has a steep learning curve in that it has traditionally been used through the command-line interface, and has a lengthy set of commands you must learn how to use to work with it efficiently. Fortunately, there are some good GUI-based applications to help you with this, but to really be a Git master you will have to know how to use in from the console.
  • At times it can be difficult to determine just what action is appropriate when a mistake has been made in a Git commit. A deep understanding of how Git works can be required to correctly navigate the steps to recover from a bad commit.
  • Git could benefit from an overhaul of its command syntax to focus on the subset of Git commands that most developers use all the time.
  • Some Git commands have names that can prompt misunderstandings as to what they actually do. A prime example of this is "git blame" which simply tells you whom made a specific change to the code, but sounds like it is going to automatically report someone to their boss for a dressing-down.
Git is very well suited for teams of software engineers who are collaborating on a software project. It makes life much easier for project managers, team leads and software architects to make decisions about which code to allow in and which to send back to the drawing board. It can also be a good tool for solo developers to use to manage and showcase their codebase and is, in fact, the versioning system on which the most popular code hosting platform, GitHub, is built on.

Git has at times been used for less technical content such as document management, but this may be a less appealing tool for non-technical professionals such as writers, whom may not want to deal with its learning curve and may find tools built into MS Office or Google Drive to be sufficient to manage document versions.
Read Joel Tanzi's full review
February 12, 2019
Cristian Bodnarasec | TrustRadius Reviewer
Score 9 out of 10
Vetted Review
Verified User
Review Source
In our organization, Git is used by several departments for file versioning, collaborative work on the same source code, change tracking, branch merging, version comparison etc. Especially because we have distributed teams all over the world, we needed a reliable tool to achieve these goals, and Git was the natural choice.
  • File versioning - easy to see the history of the changes.
  • Collaborative work on the same source code -- by providing the ability to create branches.
  • Merging branches and comparing versions made easy.
  • It is free and open source.
  • Git is so popular that when hiring, it is easy to find developers who already know this.
  • To use Git at its full capabilities, one needs to spend some time learning it.
  • Command line usage may be an issue to developers used more with GUIs. For those, you may need to add a free GUI or purchase something like Bitbucket.
  • Merging code when there are conflicts can be difficult sometimes from the command line.
  • Git may have bundled in more features that it needs. Most people just need the basics: pull, edit, push, merge.
Git is suited for doing source code versioning of all-size projects, from small to large and very large. Does very well when you have distributed teams, as it increases the team's focus, collaboration, decreases the time needed for merging code and finding differences between file versions, and decreases the time needed to make a software release. Therefore, the time to market of new projects or new features is improved (any top manager's desire).
Read Cristian Bodnarasec's full review
September 12, 2018
Matthew Mariner | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git is being used by our organization on an information technology department level. We use Git as our sole Version Control system for all of our software releases, maintenance & deployment.
  • Git is designed to work in a distributed manner, allowing each developer to run a local node that has full control of the project. Through this, the developer is able to merge his work with others on a main 'branch' & work in sync without having to worry about stepping on your other developers toes.
  • Because Git has solved the software problem of dependency, users who commit code that needs to be deleted can just roll back to a restore point, saving precious development time & tons of headaches for Information Technology. This is also very helpful when cloning projects or creating new features on the current project.
  • Git has a beautiful command line interface that is intuitive, easy to learn & extensible. You can also observe all the changes you have made in your project throughout the development with just a few simple commands. This diverse set of command-line tools is easy for the end user & very powerful.
  • There is currently no way to avoid downloading the entire commit history of a repository into the local copy - this can be problematic when cloning projects that have a history of many working submodules & packages.
  • Advanced configurations (managing multiple branches, having commands that take 2+ arguments) can sometimes be overwhelming for inexperienced users & there is definitely a learning slope for new developers.
  • You have to be precise when you use your git commands. The nature of Git commands are powerful. So powerful that if you don't know what you are doing and accidentally type a wrong command, you can cause irrevocable damage to your repository & others.
Git is a great tool, in fact, possibly the best tool to use when keeping track of all the projects through version control. Through its rigorous program, it allows the end user to see how code behaves before being merged into the main branch, and allows the intelligent user to avoid problems & fix them if necessary. It is easy to learn the common verbiage (clone, add, commit, pull & push) but at the same time have all advanced features that you can need in a future (merge, cherry pick, diffs ...) It is faster than other version control solutions currently on the market, & because it's open source it's just the best go-to for Version Control Software.
Read Matthew Mariner's full review
December 26, 2018
Chris Martin | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git is being used throughout our organization by the majority of the development teams--custom app development and off-the-shelf customized products. We primarily use Git as a source-code management, a repository, and for revision control and deployment (integrated with other apps to support this function). Being on a large software development team with multiple different developers pitching in on in-house applications, it's essential that we have a tool like Git to manage multiple processes involved with app development. Git allows us to release development changes faster and minimizes potentially negative impacts to our production releases. I also use Git for personal hobby and freelance projects.
  • Git allows for collaborative development projects, without worrying about impacting the master revision. By using branches in Git, developers can get a messy as they want, knowing that they can revert to a previous revision.
  • The ability for co-located and remote teams to develop on a single project independently. From a business perspective, this allows you to strengthen your team by not limiting your employee or team selection processes to a specific geographical location. It also eliminates the requirement for a physical centralized location for co-workers to meet and work.
  • Git allows for code-comparison so that developers can see what changes they're merging together.
  • One of my biggest gripes with Git is the learning curve. Although I am now fairly seasoned, I vividly remember the struggle to learn the ins-and-outs of Git when I first started using it. It has come a long way since I first started using Git, so there are now a lot of fixes to age-old problems, as well as GUI interfaces and 3rd party integrations, eliminating a lot of the initial learning curve for newbies.
Git is best suited for storing and managing source code in a local or remote repository. For example, myself and 5 other developer friends are working on a hobby app, but we all work full-time, busy lives, and have no clear deadline in mind to develop this app. Each of us can develop our portions of the app independently on our own time, remotely checking-in our source-code revisions to a centralized repository. As each of us pushes our code to the repository, we can begin to merge the code together into a single revision. Let's say Joe (made up friend name) decides to go a little wild and releases some really experimental code that causes the rest of the app to fail when put into production. Since we used Git, it's easy for us to revert back to a previous release, removing Joe's code changes and fixing the issues with the release.
Read Chris Martin's full review
December 17, 2018
Jakub Wilk | TrustRadius Reviewer
Score 9 out of 10
Vetted Review
Verified User
Review Source
Git is used as alternative solution to mercurial. It is used more by my department and is used to manage projects for customers. We are using them in the cloud version to share code with our customer. Each team has their own repository per customer. We usually receive this repository from the customer, because he wants to have control over this.
  • Cooperation with customer
  • Integration with visual studio
  • Distribution
  • Branching
  • Too much possibility to use console and programmers instead of concentrating on programming that has to think about pushing.
  • For me it's more a Linux than a Windows idea.
Git is suited very well for programmers and less for new programmers that are mouse oriented. it gives very good support as visual studio tool and I think that thanks to this it is used very often within the Microsoft community. I'm very much MS oriented so my perspective is different than the others and I heard that the world is not only MS. In our company it is very well suited within offshoring projects to share and distribute source code around countries and companies.
Read Jakub Wilk's full review
June 07, 2018
Joshua Weaver | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git manages the source control over all of our web-related codebases. It allows us to be light and flexible with our approach to not only development and coding, but also using a continuous integration workflow that automates processes in the deployment chain. Without Git, life as a developer would be quite painful indeed.
  • It handles many of the complicated features of version control for you like merging branches
  • It has a diverse ecosystem of tools that utilize its many features
  • Documentation for Git and its workflows can be quickly found and understood
  • Some of the commands are a little obtuse if you're not using a Git Client
  • Since Git is so widely used in the development space, it's easy to believe that growth and innovation might become stale in the area of version control. Competition is sparse these days and I'm curious if this "Standard" is going to keep moving forward somehow.
  • It's hard to fault a tool that is so ubiquitous and hardly gets in your way.
If you're developing any software that requires the need of keeping the source code around, then you should be using Git. The only time I can think of an instance where I might suggest not using Git is when you deal with an integrated and closed development environment where the source code is tightly held and managed within the IDE or environment itself. This type of development is rare these days but does still exist. As such, it would take extra measures to extract the source code out of the environment to then be able to utilize the benefits of Git.
Everyone else should utilize Git because it helps in many aspects of Source Control, for example:
  • Feature Branches during development
  • Forking entirely new versions of projects
  • Merging changes
  • Reviewing Commit histories and changes
  • Rolling back changes
Read Joshua Weaver's full review
March 15, 2018
David Petrie | TrustRadius Reviewer
Score 8 out of 10
Vetted Review
Verified User
Review Source
Git is one of the source code version control tools used at my organization (the other major one being Subversion). We are using Git to store our source code across multiple repositories and branches (features and bugs). We have a mainline development branch which all our new code is eventually pushed to, after being code reviewed by their branch using pull requests. The development branch in our Git repositories are polled for any changes, and builds are automatically run to verify the code.
  • Branching
  • What I find as the main benefit of Git is the ease that branches can be created in a repository - whether that's for working on new features or to fix bugs. It's as easy as selecting the code you want to branch from and "git checkout -b newBranch". Mainly I use this for branching from our development branch (also known as trunk) and once the code is finished, we merge the branch back into the development branch. Switching branches in Subversion is a little bit more complex, whereas Git is super easy to use.
  • Pull Requests
  • Pull requests can be created on a repository allowing code to be reviewed before being merged to the main branch. External tools like Bitbucket can be used to integrate into the Git repositories, allowing users to easily review and comment on your pull requests.
  • Local Repositories
  • When you use Git, you checkout the repository to your machine locally - and any commits that you make only affect your local repository, rather than the "real" repository at a remote location. This allows you to commit often and finalize all of your code before merging onto the latest development branch.
  • Understanding
  • Git has a little bit more of a learning curve when compared to other source control solutions, e.g. Subversion - but this is due to the more complex features it offers.
  • IDE Support
  • There aren't as many plugins for Git when compared to other source control solutions. Subversion has better plugins for IDEs and seems to be well supported.
  • Git Bash
  • Using Git bash, or the GUI that comes with Git can be slightly daunting at first. Tools like SourceTree are a solution to this problem, as they run the underlying Git commands for you.
Git is perfect for any micro-repository solutions, as it can checkout source code quickly and switch between branches easily. For example, let's say you have a new feature to add to a microservice your working on, a feature branch can be created quickly, and the working copy can be automatically switched to that new branch. If you ever need to share your code to a wider public audience, Github is great for this. Anyone with an account can check out and comment on your code and suggest changes. Also, Git is free!

As for a scenario where you wouldn't want to use Git, I've heard that Git can struggle with image files (jpg, gif) sometimes, so users with lots of images may want another solution.
Read David Petrie's full review
March 01, 2018
Christy Herron | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
I am a freelance, full-stack, software developer. Git repositories are used for all my code. I use multiple machines to create software for different platforms - Ubuntu to create websites to run on Heroku, and iOS apps. Git allows me to work on any machine while away from my normal setup. It also keeps all my source code backed-up, and I have the ability to grant access to my client if required.
  • Backup. It's the cheapest and easiest backup solution I've found in 20 years of coding. If/when a machine goes down I know I have no issues with losing work.
  • Access. I can access my code on any machine, anywhere I need to be. If I find myself with some spare time, and any machine at hand, I can dive in and carry on working.
  • Forking. It's very easy to fork new ideas without losing the current development thread.
  • I mainly use xCode and SublimeText, both of which provide a number of useful commands to backup my code to git. I'd like to see further integration, perhaps automated.
Developers often work in pairs, and on multiple projects at once. Sharing code across multiple machines can be very difficult. I don't know how we did it before Git came along - well, I do, but it wasn't pretty! Git has been a lifesaver on many occasions when systems have gone down due to hard drive failure. Git has also made it possible for me to manage and monitor the input of remote developers, as I can see in the commit logs for each push to the repositories.
Read Christy Herron's full review
April 20, 2018
Miguelangel Nuñez | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
Git is only used in our department. All our code is saved and versioned with Atlassian Stash using Git as version control system. There are at least 15+ projects in the development using this VCS.
  • Git branches allow you to work with different features at the same time.
  • Git makes programming easy and fun. You can share your code with a team peer or an entire community. You can modify the same file because you're working with local changes instead of a centralized repository.
  • At first, it's difficult to learn all the concepts, (rebase, merge, forking). They are conceptually difficult aspects to get in at first sight. You can use a graphic UI to handle it more easily.
I think you can use Git for every project you have, there aren't limitations about a kind of program or something specific. It's more about personal preferences and ease of use.
Read Miguelangel Nuñez's full review
December 14, 2017
Rene Enriquez | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
We are using Git to store our source code with all of our clients. All the technical staff uses Git as a CVS. It's an awesome product for versioning and managing source code no matter what programming language you use.
  • Versioning
  • Revision of newly implemented code by using Pull Requests
  • Branches to allow developer working in different features at the same time
  • Good integration with CI and CD tools
  • A lot of plugins and tooling are available to be integrated with Git
  • Not sure, it has been working awesome to solve our needs and there is a lot of documentation available to meet the product. As you study features you discover ways to use them.
Even if you have only one developer working on a project it is always a good idea to use a CVS like Git to version the source code. Not sure where it shouldn't be used.
Read Rene Enriquez's full review
March 07, 2018
Benjamin Hale | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
We currently use Git to track all changes in our multiple websites and landing pages, along with internal scripting projects. Git addresses the issue of keeping track of the code we have created, and maintains security and redundancy between employees. In this way, we can be sure that no one person or one device has all the information we use daily to keep our systems and websites running.
  • Git works quite well to keep a record of the code and the changes made on code for our websites and internal scripting.
  • Git allows multiple developers to work on a single project with the checkout process.
  • Git allows us to track who makes edits, when they were made, and how we can go back and fix any mistakes or bugs.
  • Git is FAST!
  • Git can be slow to learn, and much of it is done through the command line.
  • Git is a single solution for a code repository, so if you are looking for larger scale backup or documentation, it might not be the right fit.
Git is great for coding for individuals and teams. The ability to have versioning and how git is built into many development tools helps to make using one of the many git repository services easy. I can imagine that for some projects, there are better solutions for keeping code, but for most situations, git works well.
Read Benjamin Hale's full review
September 29, 2017
Ben McClure | TrustRadius Reviewer
Score 10 out of 10
Vetted Review
Verified User
Review Source
We use Git for many varying purposes. The most obvious use case is for our code-based projects. Drupal modules, WordPress plugins, Composer packages, NPM modules, you name it--it's all in GitHub! Additionally, we use GitHub for managing libraries of shared code snippets, managing configuration files, holding Ansible playbooks, and the list goes on and on.
  • Version control just about anything!
  • Manage the code of projects both large and small
  • Manage configuration
  • Facilitate easy collaboration between developers
  • Sometimes Git can be daunting to use, especially if you are new to it, and especially if you're on the command line.
  • Many Git clients exist, but it would be great if Git had an official cross-platform desktop application. However, many alternative Git desktop applications exist.
Git is suited to almost any purpose where you have some code that you want to keep somewhere, or you have some files you want to maintain a history of changes of. The only thing Git is not really well suited for is storing or version controlling large binary files.
Read Ben McClure's full review

What is Git?

Categories:  Version Control

Git Technical Details

Operating Systems: Unspecified
Mobile Application:No

Frequently Asked Questions

What is Git's best feature?

Reviewers rate Support Rating highest, with a score of 8.7.

Who uses Git?

The most common users of Git are from Mid-size Companies and the Computer Software industry.