Compare with:

    func main() {
        var m1 map[string]int
        m1["a"] = 1
        fmt.Printf("%d\n", m1["a"])
    }

http://play.golang.org/p/JJQ7dSZLeA

which yields

    panic: runtime error: assignment to entry in nil map

Well, but this again works:

    type pair struct {
        x, y int
    }
    
    func main() {
       var p pair
       fmt.Printf("%d\n", p.x)
       fmt.Printf("%d\n", p.y)
    }

That's just wrong, that declaration and initialization behaves differently depending on the type.

If I could unilaterally make just one change to Go, I'd adopt C#-style nullable types, and change everything to be nonnullable without the extra sigil (or whatever, I have no passion about the syntax itself, just the feature). This would produce, say, map[string]string vs. map?[string]string. The first would not be permitted to be null, the second would.

It would be my choice because unlike a lot of other pet ideas which would radically change Go into a new language, I'm pretty sure this would have hardly any effect... excepting of course to remove the Billion Dollar Mistake from the next up-and-coming language.

Well, I'm more or less a programming language nerd and these kind of things just hurt =).

Just try to pass a 'map' or a 'struct' to an other function. The 'map' behaves like passed by reference and the 'struct' behaves like passed by value. If you want to pass a 'struct' by reference than you have to use a pointer to a 'struct'.

Seriously? What kind of ad hoc programming language design is this?

The zero value for a map is nil. The zero value for a struct is a valid struct whose fields are all zeroed. So for pair, that would be (0, 0). The zero value for a pointer is nil. If you had said `var p *pair`, then it would be a pointer to pair, and it would be nil, and you would get a nil panic error.

You can do:

  m1 := map[string]int{}
  m1["a"] = 1

Just out of curiosity, I ran format in play.golang.org, and it creates tabs with 8 spaces -- really? Is that what the command "go format" will do, too? Is standard go formatting tabs with 8 spaces?

I think it saves tabs in source files and displays as 4 space indents

http://golang.org/doc/effective_go.html?ModPagespeed=noscrip...

Both are equivalent and none is out of date. The first is just the short-hand literal syntax. Same with &Foo{} and new(Foo).

I think the 2 are generally equals. make is used when you want to initialize a map, slice, channel with a given size.

http://golang.org/ref/spec#Making_slices_maps_and_channels

Thanks, that makes sense. So the 'make' function is more about the reserving of memory.

`make` also takes an optional size param that will let you pre-allocate a certain amount of memory if you know the size the map will grow to in advance.