Misplaced Pages

#476523

38-501: Git ( / ɡ ɪ t / ) is a distributed version control system that tracks versions of files . It is often used to control source code by programmers who are developing software collaboratively. Design goals of Git include speed, data integrity , and support for distributed , non-linear workflows — thousands of parallel branches running on different computers. As with most other distributed version control systems, and unlike most client–server systems, Git maintains

76-771: A Tcl/Tk GUI , which allows users to perform actions such as creating and amending commits, creating and merging branches, and interacting with remote repositories. In addition to the official GUI, many 3rd party interfaces exist that provide similar features to the official GUI distributed with Git, such as GitHub Desktop, SourceTree, and TortoiseGit. GUI clients make Git easier to learn and use, improving workflow efficiency and reducing errors. Popular options include cross-platform GitKraken Desktop (freemium) and Sourcetree (free/paid), or platform-specific choices like GitHub Desktop (free) for Windows/macOS and TortoiseGit (free) for Windows. While Git provides built-in GUI tools (git-gui, gitk),

114-427: A source-code management system. Torvalds explains: In many ways you can just see git as a filesystem—it's content-addressable , and it has a notion of versioning, but I really designed it coming at the problem from the viewpoint of a filesystem person (hey, kernels is what I do), and I actually have absolutely zero interest in creating a traditional SCM system. From this initial design approach, Git has developed

152-697: A build of Git for Windows, still using the MSYS2 environment. The JGit implementation of Git is a pure Java software library, designed to be embedded in any Java application. JGit is used in the Gerrit code-review tool, and in EGit, a Git client for the Eclipse IDE. Go-git is an open-source implementation of Git written in pure Go . It is currently used for backing projects as a SQL interface for Git code repositories and providing encryption for Git. Dulwich

190-588: A distributed system that he could use like BitKeeper, but none of the available free systems met his needs. He cited an example of a source-control management system needing 30 seconds to apply a patch and update all associated metadata, and noted that this would not scale to the needs of Linux kernel development, where synchronizing with fellow maintainers could require 250 such actions at once. For his design criterion, he specified that patching should take no more than three seconds, and added three more goals: These criteria eliminated every version-control system in use at

228-502: A local copy of the entire repository , a.k.a. repo, with history and version-tracking abilities, independent of network access or a central server . A repo is stored on each computer in a standard directory with additional, hidden files to provide version control capabilities. Git provides features to synchronize changes between repos that share history; copied (cloned) from each other. For collaboration, Git supports synchronizing with repos on remote machines. Although all repos (with

266-518: A non-default strategy can be selected at merge time: When there are more than one common ancestors that can be used for a three-way merge, it creates a merged tree of the common ancestors and uses that as the reference tree for the three-way merge. This has been reported to result in fewer merge conflicts without causing mis-merges by tests done on prior merge commits taken from Linux 2.6 kernel development history. Also, this can detect and handle merges involving renames. Git's primitives are not inherently

304-415: A pull request to notify maintainers of a new change; a comment thread is associated with each pull request. This allows for focused discussion of code changes . Submitted pull requests are visible to anyone with repository access. A pull request can be accepted or rejected by maintainers. Once the pull request is reviewed and approved, it is merged into the repository. Depending on the established workflow,

342-586: A service. The most popular are GitHub , SourceForge , Bitbucket and GitLab . Git, a powerful version control system, can be daunting with its command-line interface. Git GUI clients offer a graphical user interface (GUI) to simplify interaction with Git repositories. These GUIs provide visual representations of your project's history, including branches, commits, and file changes. They also streamline actions like staging changes, creating commits, and managing branches. Visual diff tools help resolve merge conflicts arising from concurrent development. Git comes with

380-547: A similar uptake among open-source projects. Distributed version control In 2010, software development author Joel Spolsky described distributed version control systems as "possibly the biggest advance in software development technology in the [past] ten years". Distributed version control systems (DVCS) use a peer-to-peer approach to version control , as opposed to the client–server approach of centralized systems. Distributed revision control synchronizes repositories by transferring patches from peer to peer. There

418-399: A source code repository that uses a distributed version control system are commonly made by means of a pull request , also known as a merge request . The contributor requests that the project maintainer pull the source code change, hence the name "pull request". The maintainer has to merge the pull request if the contribution should become part of the source base. The developer creates

SECTION 10

#1732790498477

456-503: A subset of Git. GameOfTrees is an open-source implementation of Git for the OpenBSD project. As Git is a distributed version control system, it could be used as a server out of the box. It is shipped with a built-in command git daemon which starts a simple TCP server running on the Git protocol. Dedicated Git HTTP servers help (amongst other features) by adding access control, displaying

494-452: A truly distributed project, such as Linux , every contributor maintains their own version of the project, with different contributors hosting their own respective versions and pulling in changes from other users as needed, resulting in a general consensus emerging from multiple different nodes. This also makes the process of "forking" easy, as all that is required is one contributor stop accepting pull requests from other contributors and letting

532-461: A unique blob. The relationships between the blobs can be found through examining the tree and commit objects. Newly added objects are stored in their entirety using zlib compression. This can consume a large amount of disk space quickly, so objects can be combined into packs , which use delta compression to save space, storing blobs as their changes relative to other blobs. Additionally, Git stores labels called refs (short for references) to indicate

570-538: A wider range of third-party options cater to platform-specific user preferences. The Eclipse Foundation reported in its annual community survey that as of May 2014, Git is now the most widely used source-code management tool, with 42.9% of professional software developers reporting that they use Git as their primary source-control system compared with 36.3% in 2013, 32% in 2012; or for Git responses excluding use of GitHub : 33.3% in 2014, 30.3% in 2013, 27.6% in 2012 and 12.8% in 2011. Open-source directory Open Hub reports

608-431: A working system in short order. These influences led to the following implementation choices: Another property of Git is that it snapshots directory trees of files. The earliest systems for tracking versions of source code, Source Code Control System (SCCS) and Revision Control System (RCS), worked on individual files and emphasized the space savings to be gained from interleaved deltas (SCCS) or delta encoding (RCS)

646-413: Is an implementation of Git written in pure Python with support for CPython 3.6 and later and Pypy. The libgit2 implementation of Git is an ANSI C software library with no other dependencies, which can be built on multiple platforms, including Windows, Linux, macOS, and BSD. It has bindings for many programming languages, including Ruby , Python, and Haskell . JS-Git is a JavaScript implementation of

684-537: Is no single central version of the codebase; instead, each user has a working copy and the full change history. Advantages of DVCS (compared with centralized systems) include: Disadvantages of DVCS (compared with centralized systems) include: Some originally centralized systems now offer some distributed features. Team Foundation Server and Visual Studio Team Services now host centralized and distributed version control repositories via hosting Git. Similarly, some distributed systems now offer features that mitigate

722-548: The open-source community. Today, Git is the de facto standard version control system. It is the most popular distributed version control system, with nearly 95% of developers reporting it as their primary version control system as of 2022. It is the most widely used source-code management tool among professional developers. There are offerings of Git repository services, including GitHub , SourceForge , Bitbucket and GitLab . Torvalds started developing Git in April 2005 after

760-429: The (mostly similar) versions. Later revision-control systems maintained this notion of a file having an identity across multiple revisions of a project. However, Torvalds rejected this concept. Consequently, Git does not explicitly record file revision relationships at any level below the source-code tree. These implicit revision relationships have some significant consequences: Git implements several merging strategies;

798-887: The BSDs ( DragonFly BSD , FreeBSD , NetBSD , and OpenBSD ), Solaris , macOS , and Windows . The first Windows port of Git was primarily a Linux-emulation framework that hosts the Linux version. Installing Git under Windows creates a similarly named Program Files directory containing the Mingw-w64 port of the GNU Compiler Collection , Perl 5, MSYS2 (itself a fork of Cygwin , a Unix-like emulation environment for Windows) and various other Windows ports or emulations of Linux utilities and libraries. Currently, native Windows builds of Git are distributed as 32- and 64-bit installers. The git official website currently maintains

SECTION 20

#1732790498477

836-523: The Git database that is not referred to may be cleaned up by using a garbage collection command or automatically. An object may be referenced by another object or an explicit reference. Git has different types of references. The commands to create, move, and delete references vary. git show-ref lists all references. Some types are: Git (the main implementation in C) is primarily developed on Linux , although it also supports most major operating systems, including

874-644: The Linux kernel tree at a rate of 6.7 patches per second. On 16 June, Git managed the kernel 2.6.12 release. Torvalds turned over maintenance on 26 July 2005 to Junio Hamano, a major contributor to the project. Hamano was responsible for the 1.0 release on 21 December 2005. Torvalds sarcastically quipped about the name git (which means "unpleasant person" in British English slang): "I'm an egotistical bastard, and I name all my projects after myself. First ' Linux ', now 'git'." The man page describes Git as "the stupid content tracker". The read-me file of

912-477: The code may need to be tested before being included into official release. Therefore, some projects contain a special branch for merging untested pull requests. Other projects run an automated test suite on every pull request, using a continuous integration tool, and the reviewer checks that any new code has appropriate test coverage. The first open-source DVCS systems included Arch , Monotone , and Darcs . However, open source DVCSs were never very popular until

950-403: The codebases gradually grow apart. This arrangement, however, can be difficult to maintain, resulting in many projects choosing to shift to a paradigm in which one contributor is the universal "upstream", a repository from whom changes are almost always pulled. Under this paradigm, development is somewhat recentralized, as every project now has a central repository that is informally considered as

988-408: The contents of a Git repository via the web interfaces, and managing multiple repositories. Already existing Git repositories can be cloned and shared to be used by others as a centralized repo. It can also be accessed via remote shell just by having the Git software installed and allowing a user to log in. Git servers typically listen on TCP port 9418. There are many offerings of Git repositories as

1026-554: The creation and adaptation of custom source code branches ( forks ) whose purpose might differ from the original project. In addition, it permits developers to locally clone an existing code repository and work on such from a local environment where changes are tracked and committed to the local repository allowing for better tracking of changes before being committed to the master branch of the repository. Such an approach enables developers to work in local and disconnected branches, making it more convenient for larger distributed teams. In

1064-488: The free license for BitKeeper , the proprietary source-control management (SCM) system used for Linux kernel development since 2002, was revoked for Linux. The copyright holder of BitKeeper, Larry McVoy , claimed that Andrew Tridgell had created SourcePuller by reverse engineering the BitKeeper protocols . The same incident also spurred the creation of Mercurial , another version-control system. Torvalds wanted

1102-418: The full set of features expected of a traditional SCM, with features mostly being created as needed, then refined and extended over time. Git has two data structures : a mutable index (also called stage or cache ) that caches information about the working directory and the next revision to be committed; and an object database that stores immutable objects. The index serves as a connection point between

1140-711: The issues of checkout times and storage costs, such as the Virtual File System for Git developed by Microsoft to work with very large codebases, which exposes a virtual file system that downloads files to local storage only as they are needed. A distributed model is generally better suited for large projects with partly independent developers, such as the Linux Kernel . It allows developers to work in independent branches and apply changes that can later be committed, audited and merged (or rejected) by others. This model allows for better flexibility and permits for

1178-455: The local repository, and once the development is done, the change should be integrated into the central repository as soon as possible. Organizations utilizing this centralize pattern often choose to host the central repository on a third party service like GitHub , which offers not only more reliable uptime than self-hosted repositories, but can also add centralized features like issue trackers and continuous integration . Contributions to

Git - Misplaced Pages Continue

1216-484: The locations of various commits. They are stored in the reference database and are respectively: Frequently used commands for Git's command-line interface include: A .gitignore file may be created in a Git repository as a plain text file . The files listed in the .gitignore file will not be tracked by Git. This feature can be used to ignore files with keys or passwords, various extraneous files, and large files (which GitHub will refuse to upload). Every object in

1254-407: The object database and the working tree. The object store contains five types of objects: Each object is identified by a SHA-1 hash of its contents. Git computes the hash and uses this value for the object's name. The object is put into a directory matching the first two characters of its hash. The rest of the hash is used as the file name for that object. Git stores each revision of a file as

1292-419: The official repository, managed by the project maintainers collectively. While distributed version control systems make it easy for new developers to "clone" a copy of any other contributor's repository, in a central model, new developers always clone the central repository to create identical local copies of the code base. Under this system, code changes in the central repository are periodically synchronized with

1330-518: The release of Git and Mercurial . BitKeeper was used in the development of the Linux kernel from 2002 to 2005. The development of Git , now the world's most popular version control system, was prompted by the decision of the company that made BitKeeper to rescind the free license that Linus Torvalds and some other Linux kernel developers had previously taken advantage of. Software maintenance Too Many Requests If you report this error to

1368-575: The same history) are peers, developers often use a central server to host a repo to hold an integrated copy. Git is a free and open-source software shared under the GPL-2.0-only license . Git was originally created by Linus Torvalds for version control during the development of the Linux kernel . The trademark "Git" is registered by the Software Freedom Conservancy , marking its official recognition and continued evolution in

1406-417: The source code elaborates further: "git" can mean anything, depending on your mood. The source code for Git refers to the program as "the information manager from hell". Git's design is a synthesis of Torvalds's experience with Linux in maintaining a large distributed development project, along with his intimate knowledge of file-system performance gained from the same project and the urgent need to produce

1444-412: The time, so immediately after the 2.6.12-rc2 Linux kernel development release, Torvalds set out to write his own. The development of Git began on 3 April 2005. Torvalds announced the project on 6 April and became self-hosting the next day. The first merge of multiple branches took place on 18 April. Torvalds achieved his performance goals; on 29 April, the nascent Git was benchmarked recording patches to

#476523