InfoQ

InfoQ

News

My Bookmarks

Login or Register to enable bookmarks for unlimited time.

The content has been bookmarked!

There was an error bookmarking this content! Please retry.

Google Code Gets Git

Posted by Alex Blewitt on Jul 15, 2011

Sections
Operations & Infrastructure,
Development
Topics
Java ,
Languages ,
Websphere ,
Ruby ,
Programming ,
Application Servers ,
IBM ,
Dynamic Languages ,
Git ,
Operations ,
Agile in the Enterprise ,
Companies ,
Source Control ,
Google ,
Infrastructure ,
Agile ,
github

Today, Google Code flipped the switch on supporting Git repositories. Previously, Google Code only supported Subversion and Mercurial repositories, citing an investigation dating back to 2008. The official announcement subsequently appeared.

With the meteoric rise of GitHub and the number of projects using GitHub storage with Google Code issue trackers, combined with the fact that the Eclipse Labs hosting has by and large been replaced with a bidirectional sync with GitHub, as well as the on-going Juno Git migration, Google Code was in danger of being sidelined for non-Git repositories. A Support FAQ is available, clarifying that the "smart http" protocol is required (with a base Git version of 1.6.6 required). In addition, the Eclipse Labs has gained Git support as well.

Partially, the Mercurial bias was due to Google's existing Python infrastructure, and the fact that it could map to the GFS back end in a simpler fashion than Git. However, with the release of Eclipse Indigo and the inclusion of JGit 1.0, it became possible for Google to integrate their back-end with a more up-to-date front end. Having said that, several other bindings exist for Git, such as the more open libgit2, which itself has spawned several language forks such as pygit2, which brings Git interoperability into the Python language.

Google doesn't say exactly what the implementation back-end is using, but the front-end effect is immediate; if you have an existing Google Code project, you can create a Git repository. The same is still true for new projects, which get a choice which repository you want to use.

It's unlikely that support for either Mercurial or Git will be dropped from Google Code in the future, but the days of SVN are likely to be numbered. The only major player whose future is bet on Hg is Bitbucket, who were acquired by Atlassian less than a year ago. The only significant player still using Mercurial is the OpenJDK forest at hg.java.net which is the development ecosystem that Sun initially set up.

Whatever the implementation or reasons behind it, Google Code's availability of Git repositories is only likely to swing the balance towards Git as the de-facto repository of choice for new and existing open-source projects.

Update It is possible for existing projects to switch over to Git repositories. However, note that the Wiki content of the project is also stored in a version controlled repository; in the case of SVN, in the /wiki directory, and in the case of Git or Hg in separate domains at wiki.projectname.googlecode.com/git (or /hg). As a result, when you move from one repository format to another, you need to ensure your Wiki pages are migrated, since they're not migrated automatically for you. Projects that are using Google Code for wiki/issues but GitHub for sourcing would be advised to make a local Git copy of the wiki (with Git svn clone, for example) prior to switching over, in order to minimise the wiki page downtime.

  • This article is part of a featured topic series on Agile
So sad for mercurial by 茅 盛 Posted
Kiln uses Mercurial by Roopesh Shenoy Posted
The backend is Dulwich by Don Brown Posted
There are other "significant players" still using Mercurial by Mark Reinhold Posted
  1. Back to top

    So sad for mercurial

    by 茅 盛

    The remark for the mercurial share is so sad, but it is true, which makes it more sad.

  2. Back to top

    Kiln uses Mercurial

    by Roopesh Shenoy

    Remember the good folks at FogCreek, guys behind Stackoverflow/StackExchange, and makers of FogBugz? Well they also make Kiln which is based on Mercurial. I don't know if they count as a big player, but they are pretty smart and respected folks..

  3. Back to top

    The backend is Dulwich

    by Don Brown

    From the HackerNews thread, the word is the git implementation is Dulwich.

  4. Back to top

    There are other "significant players" still using Mercurial

    by Mark Reinhold

    OpenJDK is not the "only significant player still using Mercurial". Python and Mozilla are at least as notable.

Educational Content

Evolution in Data Integration From EII to Big Data

Approaches to integrating data are changing with emergence of cloud computing.

Winning Hearts and Minds: How to Embed UX from Scratch in a Large Organization

Michele Ide-Smith presents the lessons learned in the process of introducing UX principles and techniques into a large organization through a series of small steps.

LMAX Disruptor: 100K TPS at Less than 1ms Latency

Dave Farley and Martin Thompson discuss solutions for doing low-latency high throughput transactions based on the Disruptor concurrency pattern.

Thoughts on Test Automation in Agile

Rajneesh Namta shares his thoughts, experiences, and some of the critical lessons learned while implementing software test automation on a recent Agile project.

Actor Interaction Patterns

Dale Schumacher presents several patterns of actor interaction that can be used in collaborative programs written in any language.

Scalaz: Functional Programming in Scala

Rúnar Bjarnason discusses Scalaz, a Scala library of pure data structures, type classes, highly generalized functions, and concurrency abstractions to perform functional programming in Scala.

Faster, Better, Higher – But How?

One of the main challenges when designing software architecture is considering quality attributes. Not only their design turns out to be difficult, but also the specification of these attributes.

Software Naturalism - Embracing the Real Behind the Ideal

Michael Feathers analyzes real code bases concluding that code is not nearly as beautiful as designers aspire to, discussing the everyday decisions that alter the code bit by bit.