New stable release of Go

In Go, something implements an Interface by virtue of having the right method. No "implements" declaration is necessary. This is statically typed and safe at compile time, while Python is not.

Does anyone know what this feature/pattern is called? As far as I know, Go is the first language to have this feature. Seems different from "Duck Typing" to me..

Reference: http://golang.org/doc/go_faq.html#types

Rather than requiring the programmer to declare ahead of time that two types are related, in Go a type automatically satisfies any interface that specifies a subset of its methods. Besides reducing the bookkeeping, this approach has real advantages. Types can satisfy many interfaces at once, without the complexities of traditional multiple inheritance. Interfaces can be very lightweight—having one or even zero methods in an interface can express useful concepts. Interfaces can be added after the fact if a new idea comes along or for testing—without annotating the original types. Because there are no explicit relationships between types and interfaces, there is no type hierarchy to manage or discuss.

What evidence do you have that it cripples the language? And can you point to a single 'asymmetric feature' (whatever that means) caused by this?

If you read any of the interviews with Rob, he clearly points out that the compile speed has little to do with it being 'single pass', and all to do with the package system.

In my subjective experience the compiler is way faster than Java or C# compilers, and they still have plenty of room to optimize compiler speed (for example, there is plenty of stuff the compiler could do in parallel but at the moment doesn't because they have tried to keep the toolchain as simple as possible specially while the language is changing so fast.)

That's just not true - go is not single pass (as I understand it). There are separate passes performed for top-level types and code blocks, for example, and you can forward reference all you like.

Actually, I've made a couple contributions to the language so have played with the internal implementation, and in fact the parse is done in one pass, setting up internal representations of the types/names/etc. before type-checking of top-level types is performed in a separate pass, then variable assignments, then function bodies. I can't see how this is single-pass, e.g. src/cmd/gc/lex.c:238:-

    // Process top-level declarations in three phases.
    // Phase 1: const, type, and names and types of funcs.
    //   This will gather all the information about types
    //   and methods but doesn't depend on any of it.
    // Phase 2: Variable assignments.
    //   To check interface assignments, depends on phase 1.
    // Phase 3: Function bodies.
    defercheckwidth();
    for(l=xtop; l; l=l->next)
        if(l->n->op != ODCL && l->n->op != OAS)
            typecheck(&l->n, Etop);
    for(l=xtop; l; l=l->next)
        if(l->n->op == ODCL || l->n->op == OAS)
            typecheck(&l->n, Etop);
    resumetypecopy();
    resumecheckwidth();
    for(l=xtop; l; l=l->next)
        if(l->n->op == ODCLFUNC)
            funccompile(l->n, 0);
    if(nerrors == 0)
        fninit(xtop);
    while(closures) {
        l = closures;
        closures = nil;
        for(; l; l=l->next)
            funccompile(l->n, 1);
    }
    dclchecks();

One thing that go avoids is weird syntactic conflicts which require big lexer/parser hacks to work around. C# has quite a few of those, e.g. Foo<Bar<Baz>>> - that's emphatically not the same thing as a single-pass compiler.

Actually Rob has talked about this[1] and highlights dependency management as the most important factor.

I use C# in my day job and find the go compiler considerably quicker, incidentally.

[1]:http://www.infoq.com/interviews/pike-google-go

(And just so we're clear: I actually like OCaml and have never used Go. So I'm not trying to wave some Go fanboy flag or anything. Those are just the numbers.)

Yes, Go is not a 'purely functional' language, or 'purely' anything, Go is a pragmatic language following from a very long tradition mostly at Bell Labs.

In Ruby just looking at the methods for strings is enough to find this like: "instance_variable_defined?", "rindex", "tr_s", "casecmp", "equal?", "eql?" and more. Yes, it is all lower case, but consistent it is certainly not.

I hope that's the "surprise" Andrew mentioned on twitter: > http://twitter.com/#!/go_nuts/status/63762141555064832

What do you like? Honest, straight question.