difference between declaring variables with var vs without var in go

I was having some trouble with step 35 in the tour of Go exercise.

Here's what my code looks like:

package main
import "code.google.com/p/go-tour/pic"
func Pic(dx, dy int) [][]uint8 {
    var pic = make([][]uint8, dy)
    for y := 0; y < dy; y++ {
        pic[y] = make([]uint8, dx)
        for x := 0; y < dx; x++ {
            pic[y][x] = uint8(x*y)
        } 
    }
    return pic
}

When looking for a solution, I found PeterSO's code which works perfectly

func main() {
    pic.Show(Pic)
}
func Pic(dx, dy int) [][]uint8 {
    pixels := make([][]uint8, dy)
    for y := 0; y < dy; y++ {
        pixels[y] = make([]uint8, dx)
        for x := 0; x < dx; x++ {
            pixels[y][x] = uint8(x * y)
        }
    }
    return pixels
}

The only difference I can see, is that I'm defining the pic variable using the var keyword whereas his code is using the := assignment. Now, why does my code not work?

You wrote

for x := 0; y < dx; x++ {
	pic[y][x] = uint8(x * y)
}

in particular: y < dx, which causes,

panic: runtime error: index out of range

I wrote

    for x := 0; x < dx; x++ {
        pixels[y][x] = uint8(x * y)
    }

in particular: x < dx. Therefore, change your y to x.

package main
import "code.google.com/p/go-tour/pic"
func Pic(dx, dy int) [][]uint8 {
    var pic = make([][]uint8, dy)
    for y :=0; y < dy; y++ {
        pic[y] = make([]uint8, dx)
        for x :=0; x<dx; x++ {
            pic[y][x] = uint8(x*y)
        } 
    }
    return pic
}
func main() {
    pic.Show(Pic)
}

http://play.golang.org/p/UvGgszFhl-

> Variable declarations
>
> A variable declaration creates a variable, binds an identifier to it
> and gives it a type and optionally an initial value.
>
> VarDecl = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
> VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
>
> Short variable declarations
>
> A short variable declaration uses the syntax:
>
> ShortVarDecl = IdentifierList ":=" ExpressionList .
>
> It is a shorthand for a regular variable declaration with initializer
> expressions but no types:
>
> "var" IdentifierList = ExpressionList .
>
> Unlike regular variable declarations, a short variable declaration may
> redeclare variables provided they were originally declared earlier in
> the same block with the same type, and at least one of the non-blank
> variables is new.

In your code var pic = make([][]uint8, dy) and the short form pic := make([][]uint8, dy) will both work.

If you use the :=, the type of the variable is implied from the expression on the right of the sign. If you use =, no assumption is made and you need to specify the type yourself.

In this case, you should write it like this:

var pic [][]uint8 = make([][]uint8, dy)

but this is indeed better because shorter and as clear:

pic := make([][]uint8, dy)