Git (software)

For other uses, see Git (disambiguation).
Git

A command-line session showing repository creation, addition of a file, and remote synchronization
Original author(s) Linus Torvalds[1]
Developer(s) Junio Hamano,
Linus Torvalds,
and many others
Initial release 7 April 2005 (2005-04-07)
Stable release 2.8.2 / 29 April 2016 (2016-04-29)
Development status Active
Written in C, Shell, Perl, Tcl, Python[2]
Operating system Linux, POSIX, Windows, OS X
Type Version control
License GNU General Public License v2,[3] GNU Lesser General Public License 2.1[4]
Website git-scm.com

Git (/ɡɪt/[5]) is a version control system that is widely used for software development[6] and other version control tasks. It is a distributed revision control system with an emphasis on speed,[7] data integrity,[8] and support for distributed, non-linear workflows.[9] Git was initially designed and developed in 2005 by Linux kernel developers (including Linus Torvalds) for Linux kernel development.[10]

As with most other distributed version control systems, and unlike most client–server systems, every Git working directory is a full-fledged repository with complete history and full version-tracking capabilities, independent of network access or a central server.[11] Like the Linux kernel, Git is free 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 previously used to maintain the project.[12] The copyright holder of BitKeeper, Larry McVoy, had withdrawn gratis use of the product after claiming that Andrew Tridgell had reverse-engineered the BitKeeper protocols.[13]

Torvalds wanted a distributed system that he could use like BitKeeper, but none of the available free systems met his needs, particularly in terms of performance. Torvalds cited an example of a source-control management system requiring 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 syncing with fellow maintainers could require 250 such actions at a time. For his design criteria, he specified that patching should take no more than three seconds,[7] and added an additional three points:

These criteria eliminated every then-existing version-control system except Monotone. Performance considerations excluded this, too.[9] So immediately after the 2.6.12-rc2 Linux kernel development release, Torvalds set out to write his own system.[9]

Torvalds 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'."[14][15] The man page describes Git as "the stupid content tracker".[16] The readme file of the source code elaborates further:[17]

	GIT - the stupid content tracker

"git" can mean anything, depending on your mood.

 - random three-letter combination that is pronounceable, and not
   actually used by any common UNIX command.  The fact that it is a
   mispronounciation of "get" may or may not be relevant.
 - stupid. contemptible and despicable. simple. Take your pick from the
   dictionary of slang.
 - "global information tracker": you're in a good mood, and it actually
   works for you. Angels sing, and a light suddenly fills the room. 
 - "goddamn idiotic truckload of sh*t": when it breaks

The development of Git began on 3 April 2005.[18] Torvalds announced the project on 6 April;[19] it became self-hosting as of 7 April.[18] The first merge of multiple branches took place on 18 April.[20] 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 per second.[21] On 16 June Git managed the kernel 2.6.12 release.[22]

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

Version Original release date Latest version Release date Status
Old version, no longer supported: 0.99 2005-07-11 0.99.9n 2005-12-15
Old version, no longer supported: 1.0 2005-12-21 1.0.13 2006-01-27
Old version, no longer supported: 1.1 2006-01-08 1.1.6 2006-01-30
Old version, no longer supported: 1.2 2006-02-12 1.2.6 2006-04-08
Old version, no longer supported: 1.3 2006-04-18 1.3.3 2006-05-16
Old version, no longer supported: 1.4 2006-06-10 1.4.4.5 2008-07-16
Old version, no longer supported: 1.5 2007-02-14 1.5.6.6 2008-12-17
Old version, no longer supported: 1.6 2008-08-17 1.6.6.3 2010-12-15
Old version, no longer supported: 1.7 2010-02-13 1.7.12.4 2012-10-17
Old version, no longer supported: 1.8 2012-10-21 1.8.5.6 2014-12-17
Old version, no longer supported: 1.9 2014-02-14 1.9.5 2014-12-17
Old version, no longer supported: 2.0 2014-05-28 2.0.5 2014-12-17
Old version, no longer supported: 2.1 2014-08-16 2.1.4 2014-12-17
Old version, no longer supported: 2.2 2014-11-26 2.2.3 2015-09-04
Old version, no longer supported: 2.3 2015-02-05 2.3.10 2015-09-29
Older version, yet still supported: 2.4 2015-04-30 2.4.11 2016-03-17
Older version, yet still supported: 2.5 2015-07-27 2.5.5 2016-03-17
Older version, yet still supported: 2.6 2015-09-28 2.6.6 2016-03-17
Older version, yet still supported: 2.7 2015-10-04 2.7.4 2016-03-17
Current stable version: 2.8 2016-03-28 2.8.2 2016-04-29
Future release: 2.9
Legend:
Old version
Older version, still supported
Latest version
Latest preview version
Future release

Design

Git's design was inspired by BitKeeper and Monotone.[25][26] 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.[26] The core Git project has since become a complete version control system that is usable directly.[27] While strongly influenced by BitKeeper, Torvalds deliberately avoided conventional approaches, leading to a unique design.[28]

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:

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. A core assumption in Git is that a change will be merged more often than it is written, as it is passed around various reviewers. Branches in Git are very lightweight: A branch in Git is only a reference to a single 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 entire development history, and changes are copied from one such repository to another. These changes are imported as additional development branches, and can be merged in the same way as a locally developed branch.
Compatibility with existing systems/protocols
Repositories can be published via HTTP, FTP, rsync (until Git 2.8.0[29]), or a Git protocol over either a plain socket, or ssh. Git also has a CVS server emulation, which enables the use of existing 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,[30] and performance tests done by Mozilla[31] showed it was an order of magnitude faster than some version-control systems, and fetching version history from a locally stored repository can be one hundred times faster than fetching it from the remote server.[32]
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 additional data at the nodes as well as the leaves.[33] (Mercurial and Monotone also have this property.)
Toolkit-based design
Git was designed as a set of programs written in C, and a number of shell scripts that provide wrappers around those programs.[34] 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.[35]
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 required.
Garbage accumulates unless 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.[36]
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 in a single file (or network byte stream) called packfile, delta-compressed among themselves. 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 (newly added history) are still stored singly, and periodic repacking is required to maintain space efficiency. The process of packing the repository can be very computationally expensive. By allowing objects to exist in the repository in a loose, but quickly generated format, Git allows the expensive pack operation to be deferred until later when time does not matter (e.g. the end of the work day). Git does periodic repacking automatically but manual repacking is also possible with the git gc command. For data integrity, both packfile and its index have SHA-1 checksum inside, and also the file name of packfile contains a SHA-1 checksum. To check integrity, 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, SCCS and 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.[37] Consequently, Git does not explicitly record file revision relationships at any level below the source code tree.

Implicit revision relationships have some significant consequences:

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

Data structures

Git's primitives are not inherently a source code management (SCM) system. Torvalds explains,[45]

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 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 the full set of features expected of a traditional SCM,[27] with features mostly being created as needed, then refined and extended over time.

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 object database contains four types of objects:

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

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.

Git servers typically listen on TCP port 9418.[46]

References

Every object in the Git database which 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 (software)[47]
tags
see above.

Implementations

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, OS X, and Microsoft Windows.[48]

The first Microsoft 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 5,236 files in 580 directories. These include 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.

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

The Dulwich implementation of Git is a pure Python software component for Python 2.[50]

The libgit2 implementation of Git is an ANSI C software library with no other dependencies, which can be built on multiple platforms including Microsoft Windows, Linux, Mac OS X, 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 server

As Git is a distributed version control system, it can be used as a server out of the box. 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.

Remote file store and shell access
A Git repository can be cloned to a shared file system, and accessed by other persons. It can also be accessed via remote shell just by having the Git software installed and allowing a user to log in.[56]
Git daemon, instaweb
Git daemon allows users to share their own repository to colleagues quickly. Git instaweb allows users to provide web view to the repository. As of 2014-04 instaweb does not work on Windows. Both can be seen in the line of Mercurial's "hg serve".[57][58]
Gitolite
Gitolite is an access control layer on top of Git, providing fine access control to Git repositories. It relies on other software to remotely view the repositories on the server.[59][60]
Apache Allura
Apache Allura is an open-source forge software for managing source code repositories, bug reports, discussions, wiki pages, blogs and more for any number of individual projects.
Gerrit
Gerrit provides two out of three functionalities: access control, and managing repositories. It uses jGit. To view repositories it is combined e.g. with Gitiles or GitBlit.
Gitblit
Gitblit can provide all three functions, but is in larger installations used as repository browser installed with gerrit for access control and management of repositories.[61][62] Gitblit can also provide the sync option for other repository.
Gitiles
Gitiles is a simple repository browser, usually used together with gerrit.[63][64]
Bonobo Git Server
Bonobo Git Server is a simple Git server for Windows implemented as an ASP.NET gateway.[65] It relies on the authentication mechanisms provided by Windows Internet Information Services, thus it does not support SSH access but can be easily integrated with Active Directory.
Gitorious
Gitorious is the free software behind the Git repository hosting service of the same name. In March 2015, Gitorious was acquired by GitLab.[66]
GitLab
GitLab provides a software repository service. It offers a web interface like GitHub, and is written in Ruby.
Djacket 
Djacket is a free and open source Git server like GitHub, meant for personal and small business usages. It is written in Python and Django framework.
Gogs
Gogs is another self-hosted Git service, written in Go. It provides similar features to GitLab as a web interface.[67]
GitHub
GitHub is a website where you can upload a copy of your Git repository. It is a Git repository hosting service, which offers all of the distributed revision control and source code management (SCM) functionality of Git as well as adding its own features. Unlike Git, which is strictly a command-line tool, GitHub provides a web-based graphical interface and desktop as well as mobile integration. It also provides access control and several collaboration features such as wikis, task management, bug tracking and other features that can be helpful for projects. It allows you to collaborate with other people on a project. It does that by providing a centralized location to share the repository, a web-based interface to view it, and features like forking, pull requests distributed revision control, issues, and wikis.
Bitbucket
Bitbucket is a web-based hosting service for projects that use either the Git (since October 2011) or the Mercurial (since launch) revision control systems. Bitbucket offers both commercial plans and free accounts.
Sourcegraph
Sourcegraph is a self-hosted Git service, written in Go. It also provides jump-to-definition, cross-reference, and semantic search features (by analyzing code in several languages).[68]
Commercial products
Commercial programs are also available to be installed on premises, amongst them GitHub Software (using native Git, available as a vm), Stash (using a custom front-end and native Git in the backend), Team Foundation Server (using libgit2).[69]

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

The UK IT jobs website itjobswatch.co.uk reports that as of late December 2014, 23.58% of UK permanent software development job openings have cited Git,[73] ahead of 16.34% for Subversion,[74] 11.58% for Microsoft Team Foundation Server,[75] 1.62% for Mercurial,[76] and 1.13% for Visual SourceSafe.[77]

Security

On 17 December 2014, an exploit was found affecting the Windows and Mac versions of the Git client. An attacker could perform arbitrary code execution on a Windows or Mac 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 doesn't 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 nature 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 existing 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 on the next day.[78][79]

git version 2.6.1, released on 29 September 2015, contained a patch for a security vulnerability (CVE-2015-7545)[80] which allowed arbitrary code execution.[81] 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.[82] An attacker could use the exploit via a man-in-the-middle attack if the connection was unencrypted,[82] 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.[82]

See also

References

  1. ↑ "Initial revision of "git", the information manager from hell". Github. 8 April 2005. Retrieved 26 December 2015.
  2. ↑ "Git Source Code Mirror". Retrieved 2015-11-04.
  3. ↑ "Git's GPL license at github.com". github.com. 18 January 2010. Retrieved 12 October 2014.
  4. ↑ "Git's LGPL license at github.com". github.com. 20 May 2011. Retrieved 12 October 2014.
  5. ↑ "Tech Talk: Linus Torvalds on git (at 00:01:30)". YouTube. Retrieved 2014-07-20.
  6. ↑ Scopatz, Anthony; Huff, Kathryn D. (2015). Effective Computation in Physics. O'Reilly Media, Inc. p. 351. ISBN 9781491901595. Retrieved 20 April 2016.
  7. 1 2 Torvalds, Linus (2005-04-07). "Re: Kernel SCM saga..". linux-kernel (Mailing list). "So I'm writing some scripts to try to track things a whole lot faster."
  8. 1 2 Torvalds, Linus (2007-06-10). "Re: fatal: serious inflate inconsistency". git (Mailing list). A brief description of Git's data integrity design goals.
  9. 1 2 3 4 5 Linus Torvalds (2007-05-03). Google tech talk: Linus Torvalds on git. Event occurs at 02:30. Retrieved 2007-05-16.
  10. ↑ "A Short History of Git". Pro Git (2nd ed.). Apress. 2014. Retrieved 26 December 2015.
  11. ↑ Chacon, Scott (24 December 2014). Pro Git (2nd ed.). New York, NY: Apress. pp. 29–30. ISBN 978-1-4842-0077-3.
  12. ↑ BitKeeper and Linux: The end of the road? | linux.com
  13. ↑ McAllister, Neil (2005-05-02). "Linus Torvalds' BitKeeper blunder". InfoWorld (IDG). Retrieved 2015-09-08.
  14. ↑ "GitFaq: Why the 'Git' name?". Git.or.cz. Retrieved 2012-07-14.
  15. ↑ "After controversy, Torvalds begins work on 'git'". PC World. 2012-07-14. Torvalds seemed aware that his decision to drop BitKeeper would also be controversial. When asked why he called the new software, "git", British slang meaning "a rotten person", he said. "I'm an egotistical bastard, so I name all my projects after myself. First Linux, now git"
  16. ↑ "git(1) Manual Page". Retrieved 2012-07-21.
  17. ↑ "Initial revision of "git", the information manager from hell · git/git@e83c516". GitHub. Retrieved 2016-01-21.
  18. 1 2 Torvalds, Linus (2007-02-27). "Re: Trivia: When did git self-host?". git (Mailing list).
  19. ↑ Torvalds, Linus (2005-04-06). "Kernel SCM saga..". linux-kernel (Mailing list).
  20. ↑ Torvalds, Linus (2005-04-17). "First ever real kernel git merge!". git (Mailing list).
  21. ↑ Mackall, Matt (2005-04-29). "Mercurial 0.4b vs git patchbomb benchmark". git (Mailing list).
  22. ↑ Torvalds, Linus (2005-06-17). "Linux 2.6.12". git-commits-head (Mailing list).
  23. ↑ Torvalds, Linus (2005-07-27). "Meet the new maintainer...". git (Mailing list).
  24. ↑ Hamano, Junio C. (2005-12-21). "Announce: Git 1.0.0". git (Mailing list).
  25. ↑ Torvalds, Linus (2006-05-05). "Re: [ANNOUNCE] Git wiki". linux-kernel (Mailing list). "Some historical background" on Git's predecessors
  26. 1 2 Torvalds, Linus (2005-04-08). "Re: Kernel SCM saga". linux-kernel (Mailing list). Retrieved 2008-02-20.
  27. 1 2 Torvalds, Linus (2006-03-23). "Re: Errors GITtifying GCC and Binutils". git (Mailing list).
  28. ↑ Torvalds, Linus (2006-10-20). "Re: VCS comparison table". git (Mailing list). A discussion of Git vs. BitKeeper
  29. ↑ Git 2.8.0 Release Notes "Documentation/RelNotes/2.8.0.txt". 2016-03-29.
  30. ↑ Torvalds, Linus (2006-10-19). "Re: VCS comparison table". git (Mailing list).
  31. ↑ Jst's Blog on Mozillazine "bzr/hg/git performance". Archived from the original on 29 May 2010. Retrieved 12 February 2015.
  32. ↑ Dreier, Roland (2006-11-13). "Oh what a relief it is"., observing that "git log" is 100x faster than "svn log" because the latter has to contact a remote server.
  33. ↑ "Trust". Git Concepts. Git User's Manual. 2006-10-18.
  34. ↑ Torvalds, Linus. "Re: VCS comparison table". git (Mailing list). Retrieved 2009-04-10., describing Git's script-oriented design
  35. ↑ iabervon (2005-12-22). "Git rocks!"., praising Git's scriptability
  36. ↑ "Git User's Manual". 2007-08-05.
  37. ↑ Torvalds, Linus (2005-04-10). "Re: more git updates..". linux-kernel (Mailing list).
  38. ↑ Haible, Bruno (2007-02-11). "how to speed up "git log"?". git (Mailing list).
  39. ↑ Torvalds, Linus (2006-03-01). "Re: impure renames / history tracking". git (Mailing list).
  40. ↑ Hamano, Junio C. (2006-03-24). "Re: Errors GITtifying GCC and Binutils". git (Mailing list).
  41. ↑ Hamano, Junio C. (2006-03-23). "Re: Errors GITtifying GCC and Binutils". git (Mailing list).
  42. ↑ Torvalds, Linus (2006-11-28). "Re: git and bzr". git (Mailing list)., on using git-blame to show code moved between source files
  43. ↑ Torvalds, Linus (2007-07-18). "git-merge(1)".
  44. ↑ Torvalds, Linus (2007-07-18). "CrissCrossMerge".
  45. ↑ Torvalds, Linus (2005-04-10). "Re: more git updates...". linux-kernel (Mailing list).
  46. ↑ "1.4 Getting Started – Installing Git". git-scm.com. Retrieved 2013-11-01.
  47. ↑ Gerrit Code Review – Project Configuration File Format
  48. ↑ "downloads". Retrieved 14 May 2012.
  49. ↑ "JGit". Retrieved 24 Aug 2012.
  50. ↑ "Dulwich". Retrieved 27 Aug 2012.
  51. ↑ "libgit2". Retrieved 24 Aug 2012.
  52. ↑ "rugged". Retrieved 24 Aug 2012.
  53. ↑ "pygit2". Retrieved 24 Aug 2012.
  54. ↑ "hlibgit2". Retrieved 30 Apr 2013.
  55. ↑ https://github.com/creationix/js-git "js-git: a JavaScript implementation of Git." Retrieved 13 August 2013.
  56. ↑ 4.4 Git on the Server – Setting Up the Server, Pro Git.
  57. ↑ hosting a Git repository on windows
  58. ↑ git-instaweb manual page
  59. ↑ Hosting git repositories
  60. ↑ gitolite source code and description
  61. ↑ Gitblit Homepage
  62. ↑ Wikimedia Gitblit installation
  63. ↑ Gitiles Homepage
  64. ↑ Android source code repositories
  65. ↑ Bonobogit
  66. ↑ "GitLab acquires Gitorious to bolster its on premises code collaboration platform". GitLab. 3 March 2015. Retrieved 13 March 2015.
  67. ↑ "Gogs: A painless self-hosted Git service." http://gogs.io/
  68. ↑ "Sourcegraph: the intelligent, hackable code host." https://sourcegraph.com/
  69. ↑ "Microsoft embraces git with new TFS support, Visual Studio integration". Retrieved 1 Feb 2013.
  70. ↑ "Eclipse Community Survey 2014 results | Ian Skerrett". Ianskerrett.wordpress.com. 2014-06-23. Retrieved 2014-06-23.
  71. ↑ "Results of Eclipse Community Survey 2012".
  72. ↑ "Compare Repositories – Open Hub".
  73. ↑ "Git (software) Jobs, Average Salary for Git Distributed Version Control System Skills". Itjobswatch.co.uk. Retrieved 2014-12-31.
  74. ↑ "Subversion Jobs, Average Salary for Apache Subversion (SVN) Skills". Itjobswatch.co.uk. Retrieved 2014-12-31.
  75. ↑ "Team Foundation Server Jobs, Average Salary for Microsoft Team Foundation Server (TFS) Skills". Itjobswatch.co.uk. Retrieved 2014-12-31.
  76. ↑ "Mercurial Jobs, Average Salary for Mercurial Skills". Itjobswatch.co.uk. Retrieved 2014-12-31.
  77. ↑ "VSS/SourceSafe Jobs, Average Salary for Microsoft Visual SourceSafe (VSS) Skills". Itjobswatch.co.uk. Retrieved 2014-12-31.
  78. ↑ Pettersen, Tim (20 December 2014). "Securing your Git server against CVE-2014-9390". Retrieved 22 December 2014.
  79. ↑ Hamano, J, C. (18 December 2014). "[ANNOUNCE] Git v2.2.1 (and updates to older maintenance tracks)". Newsgroup: gmane.linux.kernel,gmane.comp.version-control.git Check |newsgroup= value (help). Retrieved 22 December 2014.
  80. ↑ "CVE-2015-7545". 15 December 2015. Retrieved 26 December 2015.
  81. ↑ "Git 2.6.1". 29 September 2015. Retrieved 26 December 2015.
  82. 1 2 3 Blake Burkhart; et al. (5 October 2015). "Re: CVE Request: git". Retrieved 26 December 2015.

External links

Wikimedia Commons has media related to Git.
Wikibooks has a book on the topic of: Git
This article is issued from Wikipedia - version of the Wednesday, May 04, 2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.