TrustRadius Insights for Git are summaries of user sentiment data from TrustRadius reviews and, when necessary, third party data sources.
Business Problems Solved
Git is a widely used version control system that offers a range of use cases for different teams and organizations. Engineering and dev-ops teams rely on Git to handle version control of codebases, allowing them to create branches for features and bug fixes. By using Git, they can easily merge and release code to different environments, ensuring smooth software development processes.
Freelance software developers also find value in Git as it enables them to work on multiple machines and platforms, providing flexibility and backup of source code. They appreciate the ability to easily manage and track changes in their codebase, ensuring effective collaboration with clients and the ability to revert back if needed.
Organizations benefit from Git's ability to store source code across multiple repositories and branches. They typically have a mainline development branch for code review and automated builds, allowing for efficient management of projects. Git addresses the problem of multiple people updating a codebase by managing merging of changes, storing committed changes in a log for review, and offering rollback options when necessary.
Furthermore, Git fosters collaboration and code contribution among developers by preventing conflicts and facilitating efficient software development. It is successfully utilized by various departments like Tech Writing and Implementation, helping streamline release cycles and integrating smoothly with other tools like Bitbucket for pull requests.
Additionally, Git is an essential tool for managing app development processes. Its usage ensures faster release of changes while minimizing negative impacts on existing functionalities. Many companies rely on Git to manage massive codebases and enable cross-team code review, making it a reliable solution for tracking project progress and ensuring software security vulnerabilities are addressed.
Overall, Git's ease of use and cleaner approach to version control have received praise from users. It is widely recognized as stable and reliable for managing code, providing a centralized area for sharing and collaborating on projects across different teams.
In summary, whether it's handling version control, managing projects for customers, tracking changes in websites or internal scripting projects, or enabling concurrent work, Git proves to be a valuable and versatile tool for developers, freelancers, and organizations alike.
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.
Pros
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.
Cons
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.
Likelihood to Recommend
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.
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.
Pros
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.
Cons
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.
Likelihood to Recommend
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.
VU
Verified User
Engineer in Information Technology (Information Technology and Services company, 201-500 employees)
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.
Pros
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
Cons
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
Likelihood to Recommend
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.
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.
Pros
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.
Cons
Merges sometimes will produce conflicts that are time-consuming but its resolution is trivial if you consider the history of changes.
Likelihood to Recommend
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.
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.
Pros
Ability to create branches and merge those changes in.
Diff-ing changes.
Cons
Many different GUIs, many people.
Understanding Git has a little bit more of a learning curve when compared to other source control solutions.
Likelihood to Recommend
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.
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.
Pros
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.
Cons
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.
Likelihood to Recommend
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).
We use Git across all of our development projects in order to work on multiple aspects at once and then merge branches as needed. There are four scrum teams and one Kanban team that handles hardware issues. All the scrum teams are developing and maintaining software to various degrees across the organization.
Pros
It's the best at version control that I've seen. Rollbacks are a snap.
Provides local control down the individual developer level, which in turn allows easy management back up the chain of command.
Cloning is perfect when you need to copy a project to tweak it without messing with the main branch.
Cons
If you're not a developer, it'll take some time to get the hang of it, particularly some aspects of the API.
Sometimes the parameters are WAY too long.
Likelihood to Recommend
For any code commitments from any individual developer of any talent range it's awesome. Getting the hang of it happens over time (and can be speeded up if a senior person looks over your shoulder and gives you pointers). This comes into play for testing feature sets and ensuring branches are merged correctly.
For teams where many developers are working on a single project, Git allows them to all work on the same code without messing up back end work in the process. For any bugs or defects that slip through (big ones, I mean), it's super easy to roll back to an earlier version and call it good.
VU
Verified User
Professional in Information Technology (Information Technology and Services company, 501-1000 employees)
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.
Pros
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.
Cons
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.
Likelihood to Recommend
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.
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.
Pros
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.
Cons
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.
Likelihood to Recommend
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.
VU
Verified User
Engineer in Engineering (Real Estate company, 201-500 employees)
GIT is used as a server out of the box. It is being used by the whole organization. Dedicated Git server software helps, amongst other features, to add access control, display the contents of a Git repository via the web, and help managing multiple repositories.
Pros
Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow very user-understandable.
Cons
Many commands with many options, some commands are non-intuitive and need a level of understanding the internals of Git, commands and arguments are inconsistent to some degree
Likelihood to Recommend
Staging area: Make sure your commits have logically grouped changes and not everything else you are working on.
VU
Verified User
Engineer in Information Technology (Information Technology and Services company, 501-1000 employees)
