
Go's first commit - morecoffee
https://github.com/golang/go/commit/7d7c6a97f815e9279d08cfaea7d5efb5e90695a8
======
dantaylor08
Much more interesting (first language spec commit):
[https://github.com/golang/go/commit/18c5b488a3b2e218c0e0cf2a...](https://github.com/golang/go/commit/18c5b488a3b2e218c0e0cf2a7d4820d9da93a554)

~~~
dilap
I wonder why they got rid of this one

> \- new methods can be added to a struct outside the package where the struct
> is declared (need to think through all implications)

~~~
ecnahc515
I'd have to guess it would be conflict resolution. Imagine two separately
imported packages for which you didn't write that add a method in on a type
from a third package you didn't write, all with the same name/method
signature. How does the compiler you know which of the implementations to use?

~~~
junke
Compiler warning.

\--- (edit)

The example, while being possible, looks quite improbable.

If it is only a matters of conflicting names, qualified names should be able
to resolve the ambiguity; here I suppose you imagine implementing the same
interface for the same type differently in two packages.

That a package implements an interface for the same external method for a
third-party type is already dubious. Now, you have two packages like this and
you want to import them both. That's quite a corner case.

Practically, the last package that is imported could "win" (so you can decide
which you want). The compiler has to register all the possible implementations
anyway, so a warning is trivial to emit on redefinitions.

\----

I'd guess the restriction is to allow compilation of dynamic dispatch on a
package basis (think separate compilation) instead of waiting till all
possible files have been processed.

~~~
junke
I mean dispatch in general, not necessarily dynamic dispatch.

------
bigstumpy
I don't get it. According to the github history there was a hello world commit
in 1972, conversion to C in 1974, conversion to ansi-c in 1988, then the next
commit was the first go specification in 2008.

Git was written in 2005.

What did these hello world commits have to do with go? Why are they in the git
history?

~~~
christophersu
> According to the github history there was a hello world commit in 1972

> Git was written in 2005.

Not sure about this specific case, but it isn't uncommon to migrate from
another version control system (e.g. Subversion) to Git while maintaining the
past history.

~~~
hawkice
Subversion was (to my surprise) only released in 2000, so you'd have to
migrate from something even older -- perhaps CVS (released in 1990)? RCS was
released in 1982, so you might have migrated from that. SCCS was released in
1972, so they MIGHT have used it, and kept those migrations going. But my
guess is they fudged the git history as some weird type of historical
documentation of where these languages came from?

------
teh
We had a look at first commits from various projects a while ago [1] - I like
how the first commits get cleaner the newer the projects are, presumably
because version control became more ubiquitous.

[1] [https://blog.wearewizards.io/first-
commits](https://blog.wearewizards.io/first-commits)

------
echelon
How is this so old? Was Go something that was brewing for a long time prior to
its development and debut at Google? Also, Kernighan? Maybe I live under a
rock, but I wasn't aware of his involvement.

~~~
f2f
it's a joke.

~~~
bryanlarsen
No, it's the change history of C, of which Go is a descendant.

~~~
takeda
Go is resembling Algol more.

------
maramono
What I find interesting is that there is absolutely no mention of the word
'test' in the spec. With unit testing and TDD/BDD so ubiquitous now, perhaps
new languages should be created with testing support baked in instead of it
beng added as an after-thought.

~~~
ngrilly
This commit is a joke, a wink.

