Go’s Version Control History
Posted on Monday, February 14, 2022.
Every once in a while someone notices the first commit in the Go repo is dated 1972:
% git log --reverse --stat
commit 7d7c6a97f815e9279d08cfaea7d5efb5e90695a8
Author: Brian Kernighan <bwk>
AuthorDate: Tue Jul 18 19:05:45 1972 -0500
Commit: Brian Kernighan <bwk>
CommitDate: Tue Jul 18 19:05:45 1972 -0500
hello, world
R=ken
DELTA=7 (7 added, 0 deleted, 0 changed)
src/pkg/debug/macho/testdata/hello.b | 7 +++++++
1 file changed, 7 insertions(+)
...
Obviously something silly is going on, and people usually stop there. But Go’s actual version control history is richer and more interesting. For example, there are a few more fake commits and then the fifth commit is the first real one:
commit 18c5b488a3b2e218c0e0cf2a7d4820d9da93a554
Author: Robert Griesemer <gri@golang.org>
AuthorDate: Sun Mar 2 20:47:34 2008 -0800
Commit: Robert Griesemer <gri@golang.org>
CommitDate: Sun Mar 2 20:47:34 2008 -0800
Go spec starting point.
SVN=111041
doc/go_spec | 1197 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 1197 insertions(+)
Why does that commit have a different trailer than the three fake commits?
Subversion
Go started out using Subversion, as part of a small experiment to evaluate
Subversion for wider use inside Google. The experiment did not result
in wider Subversion use, but the SVN=111041 tag in the
first real commit above
records that on the original Subversion server, that Go commit
was revision 111,041. (Subversion assigns revision numbers in increasing order,
and the server was a small monorepo being used for a few other projects besides Go.
There were not 111,040 other Go commits that didn’t make it out.)
Perforce
The SVN tags continue in the logs until July 2008, where we see one last SVN commit and then a new form:
commit 777ee7163bba96f2c9b3dfe135d8ad4ab837c062
Author: Rob Pike <r@golang.org>
AuthorDate: Mon Jul 21 16:18:04 2008 -0700
Commit: Rob Pike <r@golang.org>
CommitDate: Mon Jul 21 16:18:04 2008 -0700
map delete
SVN=128258
doc/go_lang.txt | 6 ++++++
1 file changed, 6 insertions(+)
commit 05caa7f82030327ccc9ae63a2b0121a029286501
Author: Rob Pike <r@golang.org>
AuthorDate: Mon Jul 21 17:10:49 2008 -0700
Commit: Rob Pike <r@golang.org>
CommitDate: Mon Jul 21 17:10:49 2008 -0700
help management of empty pkg and lib directories in perforce
R=gri
DELTA=4 (4 added, 0 deleted, 0 changed)
OCL=13328
CL=13328
lib/place-holder | 2 ++
pkg/place-holder | 2 ++
src/cmd/gc/mksys.bash | 0
3 files changed, 4 insertions(+)
This was the first commit after Go moved from a lightly-used Subversion server to a lightly-used Perforce server. Google was a very heavy Perforce user due to its use of a single giant monorepo for most code. Go was not part of that monorepo world, and at the time, projects that didn’t have to be on the heavily-loaded main server were hosted instead on secondary ones.
At the transition to Perforce, you can see the introduction of telltale
DELTA=, OCL=, and CL= tags.
Perforce imposes a linear ordering on change lists, like Subversion revisions,
but each change list ends up with two sequence numbers: it is assigned
one when it is created and uses that number while it is a local, pending change list,
including in our code review systems.
Then, when it is submitted and becomes part of the official history,
it is assigned a new number, to keep submitted changes in order.
The OCL= is the original change list number, while the CL= is the final one.
The R= line means that gri (Robert Griesemer) reviewed the change before
it was submitted,
using our internal code review system, then called Mondrian.
Because the server was so lightly used (and presumably the review so quick),
no new change lists had been
created or submitted while this one was pending, and its final submission
reused its original number instead of needing to create a new one.
Many other changes have the same OCL= and CL= because they were
created and submitted in a single Perforce command, without review,
like the next one:
commit c1f5eda7a2465dae196d1fa10baf6bfa9253808a
Author: Rob Pike <r@golang.org>
AuthorDate: Mon Jul 21 18:06:39 2008 -0700
Commit: Rob Pike <r@golang.org>
CommitDate: Mon Jul 21 18:06:39 2008 -0700
change date
OCL=13331
CL=13331
doc/go_lang.txt | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
You can also see from this that the DELTA= line is added
by the code review system, not Perforce:
this unreviewed change doesn’t have it.
(The last two lines are being provided by the git log --stat
command as we explore the Git version of these changes.)
The bulk of the pre-open-source development of Go was done
on that Perforce server.
Mercurial
The OCL= and CL= lines continue until we get to October 2009, when they switch to a new form:
commit 942d6590d9005f89e971ed5af0374439a264a20e
Author: Kai Backman <kaib@golang.org>
AuthorDate: Fri Oct 23 11:03:16 2009 -0700
Commit: Kai Backman <kaib@golang.org>
CommitDate: Fri Oct 23 11:03:16 2009 -0700
one more argsize fix. we were copying with the correct
alignment but not enough (duh).
R=rsc
APPROVED=rsc
DELTA=16 (13 added, 0 deleted, 3 changed)
OCL=36020
CL=36024
src/cmd/5g/ggen.c | 2 +-
test/arm-pass.txt | 17 +++++++++++++++--
2 files changed, 16 insertions(+), 3 deletions(-)
commit b74fd8ecb17c1959bbf2dbba6ccb8bae6bfabeb8
Author: Kai Backman <kaib@golang.org>
AuthorDate: Fri Oct 23 12:43:01 2009 -0700
Commit: Kai Backman <kaib@golang.org>
CommitDate: Fri Oct 23 12:43:01 2009 -0700
fix build issue cause by transition to hg
R=rsc
http://go/go-review/1013012
src/make-arm.bash | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
That commit introduces yet another kind of trailer line,
which says http://go/go-review/1013012.
At one point that link pointed, inside Google,
to an internal version of the Rietveld App Engine app,
which we used for code review on the way to submission
to a private Mercurial repo on Google Code Project Hosting.
We were doing that conversion, in October 2009, as part
of the preparation to open-source Go in November.
It was at this point, during the conversion to Mercurial,
that I introduced the “hello, world” commits.
The Subversion and Perforce repos had been Google-internal servers,
and we had stored essentially all the Go code in the world
alongside the Go implementation.
We each had “user directories” like /usr/rsc in the repo.
Those directories contained various code that wasn’t going
out in the release, whether because it was targeting Google-internal
technologies or because it was simply not worth publishing.
(You can still see references to /usr in a few commit messages
that did make it out.)
For the conversion, I ended up with a directory full of patches,
one per commit, and a script to run the patches to create a new
Mercurial repository.
Then I edited the patches (with automated help) to remove the files that weren’t
being released, including the entire /usr tree,
and to add the new open-source copyright notices to every file.
This took me about a week, and it was annoyingly difficult.
If I removed a file from some patches but then it got renamed
in others, Mercurial would complain about the rename using
a file that hadn’t been created in the first place.
And if I added a copyright notice when the file was created,
I had to be careful to update later patches to not have
merge conflicts when changing the top of the file.
And so on. I remember thinking that it was like being
a con man who constructs an elaborate false identity
and struggles to keep it all straight.
Hello, world
A month earlier, I had created object file parsing packages like debug/macho, and as test data for each of those packages I checked in an object file compiled from a trivial “hello, world” program, along with the source code for them:
commit bf69025825fd2b8e7aac01f27d5c974bd30af542
Author: Russ Cox <rsc@golang.org>
AuthorDate: Fri Sep 18 11:49:22 2009 -0700
Commit: Russ Cox <rsc@golang.org>
CommitDate: Fri Sep 18 11:49:22 2009 -0700
Mach-O file reading
R=r
DELTA=784 (784 added, 0 deleted, 0 changed)
OCL=34715
CL=34788
src/pkg/debug/macho/Makefile | 12 +
src/pkg/debug/macho/file.go | 374 +++++++++++++++++++++
src/pkg/debug/macho/file_test.go | 159 +++++++++
src/pkg/debug/macho/macho.go | 230 +++++++++++++
src/pkg/debug/macho/testdata/gcc-386-darwin-exec | Bin 0 -> 12588 bytes
src/pkg/debug/macho/testdata/gcc-amd64-darwin-exec | Bin 0 -> 8512 bytes
.../macho/testdata/gcc-amd64-darwin-exec-debug | Bin 0 -> 4540 bytes
7 files changed, 775 insertions(+)
This was the original commit that introduced src/pkg/debug/macho/testdata/hello.c, of course.
As I added copyright notices to files, it seemed wrong to
add a copyright notice to that hello.c file.
Instead, since I had the repo split into this patch-file-per-commit form,
it was easy to create a few fake commits that showed at least part of
the real history of that program, as an Easter egg for people who looked that closely:
commit 7d7c6a97f815e9279d08cfaea7d5efb5e90695a8
Author: Brian Kernighan <bwk>
AuthorDate: Tue Jul 18 19:05:45 1972 -0500
Commit: Brian Kernighan <bwk>
CommitDate: Tue Jul 18 19:05:45 1972 -0500
hello, world
R=ken
DELTA=7 (7 added, 0 deleted, 0 changed)
src/pkg/debug/macho/testdata/hello.b | 7 +++++++
1 file changed, 7 insertions(+)
commit 0bb0b61d6a85b2a1a33dcbc418089656f2754d32
Author: Brian Kernighan <bwk>
AuthorDate: Sun Jan 20 01:02:03 1974 -0400
Commit: Brian Kernighan <bwk>
CommitDate: Sun Jan 20 01:02:03 1974 -0400
convert to C
R=dmr
DELTA=6 (0 added, 3 deleted, 3 changed)
src/pkg/debug/macho/testdata/hello.b | 7 -------
src/pkg/debug/macho/testdata/hello.c | 3 +++
2 files changed, 3 insertions(+), 7 deletions(-)
commit 0744ac969119db8a0ad3253951d375eb77cfce9e
Author: Brian Kernighan <research!bwk>
AuthorDate: Fri Apr 1 02:02:04 1988 -0500
Commit: Brian Kernighan <research!bwk>
CommitDate: Fri Apr 1 02:02:04 1988 -0500
convert to Draft-Proposed ANSI C
R=dmr
DELTA=5 (2 added, 0 deleted, 3 changed)
src/pkg/debug/macho/testdata/hello.c | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
commit d82b11e4a46307f1f1415024f33263e819c222b8
Author: Brian Kernighan <bwk@research.att.com>
AuthorDate: Fri Apr 1 02:03:04 1988 -0500
Commit: Brian Kernighan <bwk@research.att.com>
CommitDate: Fri Apr 1 02:03:04 1988 -0500
last-minute fix: convert to ANSI C
R=dmr
DELTA=3 (2 added, 0 deleted, 1 changed)
src/pkg/debug/macho/testdata/hello.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
The July 1972 commit shows the very first “hello, world” program, copied from Brian Kernighan’s “A Tutorial Introduction to the Language B”:
main( ) {
extrn a, b, c;
putchar(a); putchar(b); putchar(c); putchar(’!*n’);
}
a ’hell’;
b ’o, w’;
c ’orld’;
Various online sources refer to this as a “book”, but it definitely was not. It was a printed, 17-page document that was later included as half of January 1973’s “Bell Laboratories Computing Science Technical Report #8: The Programming Language B” (still not even close to a book!). The “hello, world” program appears in section 7, preceded by the less catchy “hi!” program in section 6. As I write this blog post in 2022, I cannot find any online reference for the B tutorial being originally dated July 1972, but I believe I must have had a good reason.
The January 1974 commit converts the program to C, as found in Kernighan’s “Programming in C — A Tutorial”. The linked PDF is a retyped copy from Dennis Ritchie, without a date, but Ritchie’s “C Reference Manual” technical memo dated January 15, 1974 cites Kernighan’s tutorial as “Unpublished internal memorandum, Bell Laboratories, 1974”, implying that the tutorial must have been written in January as well. That C program was shorter than what we are used to today, but much nicer than the B program:
main( ) {
printf("hello, world");
}
I skipped over the presentation in the first edition of The C Programming Language, which looks like:
main() {
printf("hello, world\n");
}
The April 1988 commit shows the program from the “Draft-Proposed ANSI C” version of the second edition of The C Programming Language:
#include <stdio.h>
main()
{
printf("hello, world\n");
}
The second April 1988 commit shows the final full ANSI C version we know today:
#include <stdio.h>
int
main(void)
{
printf("hello, world\n");
return 0;
}
Wikipedia says the second edition was published in April 1988. I didn’t have a day, but April 1 seemed appropriate. I didn’t have a time for either one of these, so I used 02:03:04 for the second commit and therefore 02:02:04 for the first.
The email addresses in the commits are also period-appropriate,
although Mondrian’s R= and DELTA= tags clearly are not:
there was no code review happening back then!
For what it’s worth, I’ve since heard from many people about
how the 1972 dates have broken various presentations and
analyses they’ve done on the Go repository as compared to
other projects. Oops! My apologies.
(I also heard from someone who was analyzing Mercurial
repos for “branchiness” and decided to use the Go
repo as a large test case.
Their program said it had branchiness 0 and they
spent a while debugging their program before
realizing that the repo really was completely linear,
thanks to our “rebase and merge” policy.)
Public Mercurial
We published the Google Code Mercurial repo on November 10, 2009, and to mark the occasion we added one more Easter egg. A footnote in Brian Kernighan and Rob Pike’s 1984 book The Unix Programming Environment says:
Ken Thompson was once asked what he would do differently if he were redesigning the UNIX system. His reply: “I’d spell
creatwith ane.”
This refers to the creat(2) system call
and the O_CREAT file open flag.
Immediately once the release was public, Ken mailed me a change fixing this mistake:
commit c90d392ce3d3203e0c32b3f98d1e68c4c2b4c49b
Author: Ken Thompson <ken@golang.org>
AuthorDate: Tue Nov 10 15:05:15 2009 -0800
Commit: Ken Thompson <ken@golang.org>
CommitDate: Tue Nov 10 15:05:15 2009 -0800
spell it with an "e"
R=rsc
http://go/go-review/1025037
src/pkg/os/file.go | 1 +
1 file changed, 1 insertion(+)
Sadly, we didn’t execute the joke perfectly, in that the code review went to our internal Rietveld server instead of the public one. So the very next commit updated the code review server in our configuration.
But here, for posterity, is the review, preserved in my email:
So things stood from November 2009 until late 2014,
when we knew that Google Code Project Hosting was
going to shut down and we needed a new home.
After investigating a few options, we ended up using
Gerrit Code Review, which has been a fantastic choice.
Many people think of Go as being hosted on GitHub,
but GitHub is only primary for our issue tracker:
the official primary copy of the sources is on go.googlesource.com.
You can see the transition from Mercurial to Git
in the logs when the R= lines end, followed by
a few completely unreviewed commits, and then
Reviewed-by: lines begin:
commit 94151eb2799809ece7e44ce3212aa3cbb9520849
Author: Russ Cox <rsc@golang.org>
AuthorDate: Fri Dec 5 21:33:07 2014 -0500
Commit: Russ Cox <rsc@golang.org>
CommitDate: Fri Dec 5 21:33:07 2014 -0500
encoding/xml: remove SyntaxError.Byte
It is unused. It was introduced in the CL that added InputOffset.
I suspect it was an editing mistake.
LGTM=bradfitz
R=bradfitz
CC=golang-codereviews
https://golang.org/cl/182580043
src/encoding/xml/xml.go | 1 -
1 file changed, 1 deletion(-)
commit 258f53dee33b9055ea168cb186f8c076edee5905
Author: David Symonds <dsymonds@golang.org>
AuthorDate: Mon Dec 8 13:50:49 2014 +1100
Commit: David Symonds <dsymonds@golang.org>
CommitDate: Mon Dec 8 13:50:49 2014 +1100
remove .hgtags.
.hgtags | 140 ----------------------------------------------------------------
1 file changed, 140 deletions(-)
commit 369873c6e5d00314ae30276363f58e5af11b149c
Author: David Symonds <dsymonds@golang.org>
AuthorDate: Mon Dec 8 13:50:49 2014 +1100
Commit: David Symonds <dsymonds@golang.org>
CommitDate: Mon Dec 8 13:50:49 2014 +1100
convert .hgignore to .gitignore.
.hgignore => .gitignore | 9 +--------
1 file changed, 1 insertion(+), 8 deletions(-)
commit f33fc0eb95be84f0a688a62e25361a117e5b995b
Author: David Symonds <dsymonds@golang.org>
AuthorDate: Mon Dec 8 13:53:11 2014 +1100
Commit: David Symonds <dsymonds@golang.org>
CommitDate: Mon Dec 8 13:53:11 2014 +1100
cmd/dist: convert dist from Hg to Git.
src/cmd/dist/build.c | 100 ++++++++++++++++++++++++++++++---------------------
1 file changed, 59 insertions(+), 41 deletions(-)
commit 26399948e3402d3512cb14fe5901afaef54482fa
Author: David Symonds <dsymonds@golang.org>
AuthorDate: Mon Dec 8 11:39:11 2014 +1100
Commit: David Symonds <dsymonds@golang.org>
CommitDate: Mon Dec 8 04:42:22 2014 +0000
add bin/ to .gitignore.
Change-Id: I5c788d324e56ca88366fb54b67240cebf5dced2c
Reviewed-on: https://go-review.googlesource.com/1171
Reviewed-by: Andrew Gerrand <adg@golang.org>
.gitignore | 1 +
1 file changed, 1 insertion(+)
As part of the conversion from Mercurial to Git, we did not add visible lines to the commit bodies showing the old Mercurial hashes, but we did record them in the underlying Git commit objects. For example:
% git cat-file -p 7d7c6a97f815e9279d08cfaea7d5efb5e90695a8 tree e06bd601885e16ad3d72c2a8c9b411889b2e478e author Brian Kernighan <bwk> 80352345 -0500 committer Brian Kernighan <bwk> 80352345 -0500 golang-hg f6182e5abf5eb0c762dddbb18f8854b7e350eaeb hello, world R=ken DELTA=7 (7 added, 0 deleted, 0 changed) %
The golang-hg line records the original Mercurial commit hash.
And that’s the end of the story, until we move to a fifth version control system at some point in the future.