Git

From Hidden Wiki
Jump to navigation Jump to search

Template:Short description Template:Other uses Template:Use dmy dates {{#invoke:Infobox|infobox}}

Git (Template:IPAc-en)[1] is a distributed version-control system for tracking changes in source code during software development.[2] It is designed for coordinating work among programmers, but it can be used to track changes in any set of files. Its goals include speed,[3] data integrity,[4] and support for distributed, non-linear workflows.[5]

Git was created by Linus Torvalds in 2005 for development of the Linux kernel, with other kernel developers contributing to its initial development.[6] Its current maintainer since 2005 is Junio Hamano. As with most other distributed version-control systems, and unlike most client–server systems, every Git directory on every computer is a full-fledged repository with complete history and full version-tracking abilities, independent of network access or a central server.[7] Git is free and open-source software distributed under the terms of the GNU General Public License version 2.

History

Git development began in April 2005, after many developers of the Linux kernel gave up access to BitKeeper, a proprietary source-control management (SCM) system that they had formerly used to maintain the project.[8] The copyright holder of BitKeeper, Larry McVoy, had withdrawn free use of the product after claiming that Andrew Tridgell had created SourcePuller by reverse engineering the BitKeeper protocols.[9] The same incident also spurred the creation of another version-control system, Mercurial.

Linus Torvalds wanted a distributed system that he could use like BitKeeper, but none of the available free systems met his needs. Torvalds 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 criteria, he specified that patching should take no more than three seconds,[3] and added three more points:

  • Take Concurrent Versions System (CVS) as an example of what not to do; if in doubt, make the exact opposite decision.[5]
  • Support a distributed, BitKeeper-like workflow.[5]
  • Include very strong safeguards against corruption, either accidental or malicious.[4]

These criteria eliminated every then-extant version-control system, so immediately after the 2.6.12-rc2 Linux kernel development release, Torvalds set out to write his own.[5]

The development of Git began on 3 April 2005.[10] Torvalds announced the project on 6 April;[11] it became self-hosting as of 7 April.[10] The first merge of multiple branches took place on 18 April.[12] Torvalds achieved his performance goals; on 29 April, the nascent Git was benchmarked recording patches to the Linux kernel tree at the rate of 6.7 patches per second.[13] On 16 June Git managed the kernel 2.6.12 release.[14]

Torvalds turned over maintenance on 26 July 2005 to Junio Hamano, a major contributor to the project.[15] Hamano was responsible for the 1.0 release on 21 December 2005 and remains the project's maintainer.[16]

Naming

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'."[17][18] The man page describes Git as "the stupid content tracker".[19] The read-me file of the source code elaborates further:[20]

Template:Quote

Releases[21][22]

Version Original release date Latest (patch) version Release date (of patch)
Template:Version 2005-07-11 0.99.9n 2005-12-15
Template:Version 2005-12-21 1.0.13 2006-01-27
Template:Version 2006-01-08 1.1.6 2006-01-30
Template:Version 2006-02-12 1.2.6 2006-04-08
Template:Version 2006-04-18 1.3.3 2006-05-16
Template:Version 2006-06-10 1.4.4.5 2008-07-16
Template:Version 2007-02-14 1.5.6.6 2008-12-17
Template:Version 2008-08-17 1.6.6.3 2010-12-15
Template:Version 2010-02-13 1.7.12.4 2012-10-17
Template:Version 2012-10-21 1.8.5.6 2014-12-17
Template:Version 2014-02-14 1.9.5 2014-12-17
Template:Version 2014-05-28 2.0.5 2014-12-17
Template:Version 2014-08-16 2.1.4 2014-12-17
Template:Version 2014-11-26 2.2.3 2015-09-04
Template:Version 2015-02-05 2.3.10 2015-09-29
Template:Version 2015-04-30 2.4.12 2017-05-05
Template:Version 2015-07-27 2.5.6 2017-05-05
Template:Version 2015-09-28 2.6.7 2017-05-05
Template:Version 2015-10-04 2.7.6 2017-07-30
Template:Version 2016-03-28 2.8.6 2017-07-30
Template:Version 2016-06-13 2.9.5 2017-07-30
Template:Version 2016-09-02 2.10.5 2017-09-22
Template:Version 2016-11-29 2.11.4 2017-09-22
Template:Version 2017-02-24 2.12.5 2017-09-22
Template:Version 2017-05-10 2.13.7 2018-05-22
Template:Version 2017-08-04 2.14.5 2018-09-27
Template:Version 2017-10-30 2.15.3 2018-09-27
Template:Version 2018-01-17 2.16.5 2018-09-27
Template:Version 2018-04-02 2.17.2 2018-09-27
Template:Version 2018-06-21 2.18.1 2018-09-27
Template:Version 2018-09-10 2.19.2 2018-11-21
Template:Version 2018-12-09 2.20.1 2018-12-15
Template:Version 2019-02-24 2.21.0 2019-02-24
Template:Version 2019-06-07 2.22.1 2019-08-10
Template:Version 2019-08-16 2.23.0 2019-08-16
Template:Version

Design

Git's design was inspired by BitKeeper and Monotone.[23][24] Git was originally designed as a low-level version-control system engine, on top of which others could write front ends, such as Cogito or StGIT.[24] The core Git project has since become a complete version-control system that is usable directly.[25] While strongly influenced by BitKeeper, Torvalds deliberately avoided conventional approaches, leading to a unique design.[26]

Characteristics

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 a working system in short order. These influences led to the following implementation choices:Template:Citation needed

Strong support for non-linear development
Git supports rapid branching and merging, and includes specific tools for visualizing and navigating a non-linear development history. In Git, a core assumption is that a change will be merged more often than it is written, as it is passed around to various reviewers. In Git, branches are very lightweight: a branch is only a reference to one commit. With its parental commits, the full branch structure can be constructed.
Distributed development
Like Darcs, BitKeeper, Mercurial, SVK, Bazaar, and Monotone, Git gives each developer a local copy of the full development history, and changes are copied from one such repository to another. These changes are imported as added development branches and can be merged in the same way as a locally developed branch.
Compatibility with existent systems and protocols
Repositories can be published via Hypertext Transfer Protocol (HTTP), File Transfer Protocol (FTP), rsync (removed in Git 2.8.0[27]), or a Git protocol over either a plain socket, or Secure Shell (ssh). Git also has a CVS server emulation, which enables the use of existent CVS clients and IDE plugins to access Git repositories. Subversion and svk repositories can be used directly with git-svn.
Efficient handling of large projects
Torvalds has described Git as being very fast and scalable,[28] and performance tests done by Mozilla[29] showed that it was an order of magnitude faster than some version-control systems; fetching version history from a locally stored repository can be one hundred times faster than fetching it from the remote server.[30]
Cryptographic authentication of history
The Git history is stored in such a way that the ID of a particular version (a commit in Git terms) depends upon the complete development history leading up to that commit. Once it is published, it is not possible to change the old versions without it being noticed. The structure is similar to a Merkle tree, but with added data at the nodes and leaves.[31] (Mercurial and Monotone also have this property.)
Toolkit-based design
Git was designed as a set of programs written in C and several shell scripts that provide wrappers around those programs.[32] Although most of those scripts have since been rewritten in C for speed and portability, the design remains, and it is easy to chain the components together.[33]
Pluggable merge strategies
As part of its toolkit design, Git has a well-defined model of an incomplete merge, and it has multiple algorithms for completing it, culminating in telling the user that it is unable to complete the merge automatically and that manual editing is needed.
Garbage accumulates until collected
Aborting operations or backing out changes will leave useless dangling objects in the database. These are generally a small fraction of the continuously growing history of wanted objects. Git will automatically perform garbage collection when enough loose objects have been created in the repository. Garbage collection can be called explicitly using git gc --prune.[34]
Periodic explicit object packing
Git stores each newly created object as a separate file. Although individually compressed, this takes a great deal of space and is inefficient. This is solved by the use of packs that store a large number of objects delta-compressed among themselves in one file (or network byte stream) called a packfile. Packs are compressed using the heuristic that files with the same name are probably similar, but do not depend on it for correctness. A corresponding index file is created for each packfile, telling the offset of each object in the packfile. Newly created objects (with newly added history) are still stored as single objects, and periodic repacking is needed to maintain space efficiency. The process of packing the repository can be very computationally costly. By allowing objects to exist in the repository in a loose but quickly generated format, Git allows the costly pack operation to be deferred until later, when time matters less, e.g., the end of a work day. Git does periodic repacking automatically, but manual repacking is also possible with the git gc command. For data integrity, both the packfile and its index have an SHA-1 checksum inside, and the file name of the packfile also contains an SHA-1 checksum. To check the integrity of a repository, run the git fsck command.

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) 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.[35] 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:

  • It is slightly more costly to examine the change history of one file than the whole project.[36] To obtain a history of changes affecting a given file, Git must walk the global history and then determine whether each change modified that file. This method of examining history does, however, let Git produce with equal efficiency a single history showing the changes to an arbitrary set of files. For example, a subdirectory of the source tree plus an associated global header file is a very common case.
  • Renames are handled implicitly rather than explicitly. A common complaint with CVS is that it uses the name of a file to identify its revision history, so moving or renaming a file is not possible without either interrupting its history or renaming the history and thereby making the history inaccurate. Most post-CVS revision-control systems solve this by giving a file a unique long-lived name (analogous to an inode number) that survives renaming. Git does not record such an identifier, and this is claimed as an advantage.[37][38] Source code files are sometimes split or merged, or simply renamed,[39] and recording this as a simple rename would freeze an inaccurate description of what happened in the (immutable) history. Git addresses the issue by detecting renames while browsing the history of snapshots rather than recording it when making the snapshot.[40] (Briefly, given a file in revision N, a file of the same name in revision N − 1 is its default ancestor. However, when there is no like-named file in revision N − 1, Git searches for a file that existed only in revision N − 1 and is very similar to the new file.) However, it does require more CPU-intensive work every time the history is reviewed, and several options to adjust the heuristics are available. This mechanism does not always work; sometimes a file that is renamed with changes in the same commit is read as a deletion of the old file and the creation of a new file. Developers can work around this limitation by committing the rename and the changes separately.

Git implements several merging strategies; a non-default strategy can be selected at merge time:[41]

  • resolve: the traditional three-way merge algorithm.
  • recursive: This is the default when pulling or merging one branch, and is a variant of the three-way merge algorithm. Template:Quote
  • octopus: This is the default when merging more than two heads.

Data structures

Git's primitives are not inherently a source-code management system. Torvalds explains:[42] Template:Quote

From this initial design approach, Git has developed the full set of features expected of a traditional SCM,[25] with features mostly being created as needed, then refined and extended over time.

File:Git operations.svg
Some data flows and storage levels in the Git revision control system

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 immutable, append-only object database.

The index serves as connection point between the object database and the working tree.

The object database contains four types of objects:

  • A blob (binary large object) is the content of a file. Blobs have no proper file name, time stamps, or other metadata. (A blob's name internally is a hash of its content.)
  • A tree object is the equivalent of a directory. It contains a list of file names, each with some type bits and a reference to a blob or tree object that is that file, symbolic link, or directory's contents. These objects are a snapshot of the source tree. (In whole, this comprises a Merkle tree, meaning that only a single hash for the root tree is sufficient and actually used in commits to precisely pinpoint to the exact state of whole tree structures of any number of sub-directories and files.)
  • A commit object links tree objects together into a history. It contains the name of a tree object (of the top-level source directory), a time stamp, a log message, and the names of zero or more parent commit objects.
  • A tag object is a container that contains a reference to another object and can hold added meta-data related to another object. Most commonly, it is used to store a digital signature of a commit object corresponding to a particular release of the data being tracked by Git.

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 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.

References

Every object in 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 knows different types of references. The commands to create, move, and delete references vary. "git show-ref" lists all references. Some types are:

  • heads: refers to an object locally,
  • remotes: refers to an object which exists in a remote repository,
  • stash: refers to an object not yet committed,
  • meta: e.g. a configuration in a bare repository, user rights; the refs/meta/config namespace was introduced resp gets used by Gerrit,Template:Clarify[43]
  • tags: see above.

Implementations

File:GNOME gitg.png
gitg is a graphical front-end using GTK+

Git is primarily developed on Linux, although it also supports most major operating systems, including BSD, Solaris, macOS, and Windows.[44]

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 port of the GNU Compiler Collection, Perl 5, msys2.0 (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.[45]

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.[46]

go-git is an open-source implementation of Git written in pure Go.[47] It is currently used for backing projects as a SQL interface for Git code repositories[48] and providing encryption for Git.[49]

The Dulwich implementation of Git is a pure Python software component for Python 2.7, 3.4 and 3.5[50]

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.[51] It has bindings for many programming languages, including Ruby, Python, and Haskell.[52][53][54]

JS-Git is a JavaScript implementation of a subset of Git.[55]

Git GUIs

Template:See also

Git server

Template:Refimprove

File:Gitweb.png
Screenshot of Gitweb interface showing a commit diff

As Git is a distributed version-control system, it could be used as a server out of the box. It's shipped with built-in command git daemon which starts simple TCP server running on the GIT protocol.[56] Dedicated Git HTTP servers help (amongst other features) by adding access control, displaying 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.[57] Git servers typically listen on TCP port 9418.[58]

Open source

  • gitolite, scripts on top of git software to provide fine-grained access control.
  • Gerrit, a git server configurable to support code reviews and providing access via ssh, an integrated Apache MINA or OpenSSH, or an integrated Jetty web server. Gerrit provides integration for LDAP, Active Directory, OpenID, OAuth, Kerberos/GSSAPI, X509 https client certificates. With Gerrit 3.0 all configurations will be stored as git repositories, no database required to run. Gerrit has a pull-request feature implemented in its core but lacks a GUI for it.
  • Phabricator, a spin-off from Facebook. As Facebook primarily uses Mercurial, the git support is not as prominent.[59]
  • Trac, supporting git, Mercurial, and Subversion with a modified BSD license.
  • Rhodecode Community Edition (CE), supporting git, Mercurial and Subversion with a AGPLv3 license.
  • Kallithea, supporting both git and Mercurial, developed in Python with GPL license.
  • There are several other FLOSS full solutions for self-hosting, including Gogs and Gitea, a fork of Gogs, both developed in Go language with MIT license,

As service

Template:See also Best known are probably GitHub and Bitbucket offerings, but many others are available, like GitLab, Gitea, GerritForge, etc.

Adoption

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[60] 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.[61] Open-source directory Black Duck Open Hub reports a similar uptake among open-source projects.[62]

Stack Overflow has included Version control in their annual developer survey[63] in 2015 (16,694 responses),[64] 2017 (30,730 responses)[65] and 2018 (74,298 responses).[66] Git was the overwhelming favorite of responding developers in these surveys, reporting as high as 87.2% in 2018. Version control systems used by responding developers: Git (69.3% in 2015, 69.2% in 2017 and 87.2% in 2018), Subversion (36.9% in 2015, 9.1% in 2017 and 16.1% in 2018), Microsoft Team Foundation Server (12.2% in 2015, 7.3% in 2017 and 10.9% in 2018), Mercurial (7.9% in 2015, 1.9% in 2017 and 3.6% in 2018), CVS (4.2% in 2015; not listed in 2017 or 2018), Perforce (3.3% in 2015; not listed in 2017 or 2018), Microsoft Visual SourceSafe (0.6% in 2017; not listed in 2015 or 2018), Rational ClearCase (0.4% in 2017; not listed in 2015 or 2018), Zip file backups (not listed in 2015; 2.0% in 2017 and 7.9% in 2018), Copying and pasting files to network shares (not listed in 2015; 1.7% in 2017 and 7.9% in 2018), Other (5.8% in 2015, 3.0% in 2017; not listed in 2018) and None (9.3% in 2015, 4.8% in 2017 and 4.8% in 2018).

The UK IT jobs website itjobswatch.co.uk reports that as of late September 2016, 29.27% of UK permanent software development job openings have cited Git,[67] ahead of 12.17% for Microsoft Team Foundation Server,[68] 10.60% for Subversion,[69] 1.30% for Mercurial,[70] and 0.48% for Visual SourceSafe.[71]

Extensions

There are many Git extensions, like Git LFS, which started as an extension to Git in the GitHub community and now is widely used by other repositories. Extensions are usually independently developed and maintained by different people, but in some point in the future a widely used extension can be merged to Git.

Microsoft developed the Virtual File System for Git (VFS for Git; formerly Git Virtual File System or GVFS) extension to handle the size of the Windows source-code tree as part of their 2017 migration from Perforce. VFS for Git allows cloned repositories to use placeholders whose contents are downloaded only once a file is accessed.[72]

Security

Git does not provide access-control mechanisms, but was designed for operation with other tools that specialize in access control.[73]

On 17 December 2014, an exploit was found affecting the Windows and macOS versions of the Git client. An attacker could perform arbitrary code execution on a target computer with Git installed by creating a malicious Git tree (directory) named .git (a directory in Git repositories that stores all the data of the repository) in a different case (such as .GIT or .Git, needed because Git does not allow the all-lowercase version of .git to be created manually) with malicious files in the .git/hooks subdirectory (a folder with executable files that Git runs) on a repository that the attacker made or on a repository that the attacker can modify. If a Windows or Mac user pulls (downloads) a version of the repository with the malicious directory, then switches to that directory, the .git directory will be overwritten (due to the case-insensitive trait of the Windows and Mac filesystems) and the malicious executable files in .git/hooks may be run, which results in the attacker's commands being executed. An attacker could also modify the .git/config configuration file, which allows the attacker to create malicious Git aliases (aliases for Git commands or external commands) or modify extant aliases to execute malicious commands when run. The vulnerability was patched in version 2.2.1 of Git, released on 17 December 2014, and announced the next day.[74][75]

Git version 2.6.1, released on 29 September 2015, contained a patch for a security vulnerability (CVE-2015-7545)[76] that allowed arbitrary code execution.[77] The vulnerability was exploitable if an attacker could convince a victim to clone a specific URL, as the arbitrary commands were embedded in the URL itself.[78] An attacker could use the exploit via a man-in-the-middle attack if the connection was unencrypted,[78] as they could redirect the user to a URL of their choice. Recursive clones were also vulnerable, since they allowed the controller of a repository to specify arbitrary URLs via the gitmodules file.[78]

Git uses SHA-1 hashes internally. Linus Torvalds has responded that the hash was mostly to guard against accidental corruption, and the security a cryptographically secure hash gives was just an accidental side effect, with the main security being signing elsewhere.[79][80]

See also

Template:Portal

References

1 }} 
     | references-column-width 
     | references-column-count references-column-count-{{#if:1|30em}} }}
   | {{#if: 
     | references-column-width }} }}" style="{{#if: 30em
   | {{#iferror: {{#ifexpr: 30em > 1 }}
     | Template:Column-width
     | Template:Column-count }}
   | {{#if: 
     | Template:Column-width }} }} list-style-type: {{#switch: 
   | upper-alpha
   | upper-roman
   | lower-alpha
   | lower-greek
   | lower-roman = {{{group}}}
   | #default = decimal}};">
  1. ↑ Template:Cite web
  2. ↑ Template:Cite book
  3. ↑ 3.0 3.1 Template:Cite mailing list "So I'm writing some scripts to try to track things a whole lot faster."
  4. ↑ 4.0 4.1 Template:Cite mailing list
  5. ↑ 5.0 5.1 5.2 5.3 Template:Cite video
  6. ↑ Template:Cite book
  7. ↑ Template:Cite book
  8. ↑ BitKeeper and Linux: The end of the road? |linux.com Template:Webarchive
  9. ↑ Template:Cite news
  10. ↑ 10.0 10.1 Template:Cite mailing list
  11. ↑ Template:Cite mailing list
  12. ↑ Template:Cite mailing list
  13. ↑ Template:Cite mailing list
  14. ↑ Template:Cite mailing list
  15. ↑ Template:Cite mailing list
  16. ↑ Template:Cite mailing list
  17. ↑ Template:Cite web
  18. ↑ Template:Cite web
  19. ↑ Template:Cite web
  20. ↑ Template:Cite web
  21. ↑ Template:Cite web
  22. ↑ Template:Cite web
  23. ↑ Template:Cite mailing list "Some historical background" on Git's predecessors
  24. ↑ 24.0 24.1 Template:Cite mailing list
  25. ↑ 25.0 25.1 Template:Cite mailing list
  26. ↑ Template:Cite mailing list A discussion of Git vs. BitKeeper.
  27. ↑ Git 2.8.0 Release Notes Template:Cite web
  28. ↑ Template:Cite mailing list
  29. ↑ Jst's Blog on Mozillazine Template:Cite web
  30. ↑ Template:Cite web, observing that "git log" is 100x faster than "svn log" because the latter must contact a remote server.
  31. ↑ Template:Cite web
  32. ↑ Template:Cite mailing list, describing Git's script-oriented design
  33. ↑ Template:Cite web, praising Git's scriptability.
  34. ↑ Template:Cite web
  35. ↑ Template:Cite mailing list
  36. ↑ Template:Cite mailing list
  37. ↑ Template:Cite mailing list
  38. ↑ Template:Cite mailing list
  39. ↑ Template:Cite mailing list
  40. ↑ Template:Cite mailing list, on using git-blame to show code moved between source files.
  41. ↑ Template:Cite web
  42. ↑ Template:Cite mailing list
  43. ↑ Gerrit Code Review – Project Configuration File Format.
  44. ↑ Template:Cite web
  45. ↑ Template:Cite web
  46. ↑ Template:Cite web
  47. ↑ Template:Cite web
  48. ↑ Template:Citation
  49. ↑ Template:Cite web
  50. ↑ Template:Cite web
  51. ↑ Template:Cite web
  52. ↑ Template:Cite web
  53. ↑ Template:Cite web
  54. ↑ Template:Cite web
  55. ↑ Template:Cite web
  56. ↑ Template:Cite web
  57. ↑ 4.4 Git on the Server – Setting Up the Server Template:Webarchive, Pro Git.
  58. ↑ Template:Cite web
  59. ↑ Diffusion User Guide: Repository Hosting.
  60. ↑ Template:Cite web
  61. ↑ Template:Cite web
  62. ↑ Template:Cite web
  63. ↑ Stack Overflow Annual Developer Survey
  64. ↑ Template:Cite web
  65. ↑ Template:Cite web
  66. ↑ Template:Cite web
  67. ↑ Template:Cite web
  68. ↑ Template:Cite web
  69. ↑ Template:Cite web
  70. ↑ Template:Cite web
  71. ↑ Template:Cite web
  72. ↑ Template:Cite web
  73. ↑ Template:Cite web
  74. ↑ Template:Cite web
  75. ↑ Template:Cite newsgroup
  76. ↑ Template:Cite web
  77. ↑ Template:Cite web
  78. ↑ 78.0 78.1 78.2 Template:Cite web
  79. ↑ Template:Cite web
  80. ↑ Template:Cite web

External links

Template:Commons category Template:Wikibooks

Template:Revision control software

Template:Authority control

Retrieved from "http://hiddenwep33eg4w225lcdwcez4iefacwpiia6cwg7pfmcz4hvijzbgid.onion/index.php?title=Git&oldid=25734"