Download Go source:

cd /usr/local
hg clone -r release https://go.googlecode.com/hg/ go

Build Toolchain:

cd go/src
./all.bash

Add Go tools to PATH by creating /etc/profile.de/go.sh:

#!/bin/sh
export PATH="$PATH:/usr/local/go/bin"

Go Syntax Highlighting for your editor at http://go-lang.cat-v.org/text-editors/

package main
import "fmt"
 
func main() {
    fmt.Printf("Hallo Süße!\n")
}

Build & run: 8g hello.go && 8l -o hello hello.8 && ./hello

For Printf see pkg/fmt/

package main
import "fmt"
func main() {
    var i,j int                         // 2 ints, autoinitialized to zero value
    fmt.Printf("%d %d\n", i, j)         // 0 0
 
    var k,l,m,n= true, 0, 2.6, "Hello"  // missing types default to:
    fmt.Printf("%T %T %T %T\n", k,l,m,n)// -> bool int float64 string
    fmt.Printf("%v %v %v %v\n", k,l,m,n)// -> true 0 2.6 Hello
    fmt.Println(k,l,m,n)                // -> true 0 2.6 Hello
 
    o,p:= false, "World"                // short form: no type but initializers:
    fmt.Printf("%T %T\n", o,p)          // -> bool string
    fmt.Println(o,p)                    // -> false World
}

more

package main
import "fmt"
func main() {
    //var ia= [...]int{47,11}       // Create an array literal
    ia:= [...]int{47,11}            // Create an array literal - short form
 
    for i, v := range ia {          // Loop through an array
        fmt.Printf("%d %d\n", i, v)
    }
 
    var ib [3]int                   // Create arrays with ZEROED elements
    var ic [2]int
    for _, v := range ib {          // '_' means key not used
        fmt.Printf("%d \n", v)      // -> 0 0 0
    }
 
    //i=0                           // illegal, i not defined outside loop
    //ib = ia                       // illegal, different len => different types
    //ib[3]=9                       // illegal, index out of bounds
    //fmt.Println(ia == ic)         // illegal, no == operator for array
 
    ic= ia                          // copy BY VALUE
    ia[0]= 36
    fmt.Println(ia, ic)             // -> [36 11] [47 11]
 
    //i:=3
    //ib[i]=9                       // panic => runtime index check :-)
}

package main
import "fmt"
func main() {
    a:= [...]int{0,1,2,3}               // an array to play with
    sa:= a[:]                           // Create slice from whole array
    sb:= a[:2]                          // Create slice from last part
    sc:= a[2:]                          // Create slice from first part
    fmt.Println(sa, len(sa), cap(sa))   // -> [0 1 2 3] 4 4
    fmt.Println(sb, len(sb), cap(sb))   // -> [0 1] 2 4(!)
    fmt.Println(sc, len(sc), cap(sc))   // -> [2 3] 2 2
 
    sa[0]=6                             // all slices point to the same array:
    sb[1]=7                             //
    sc[0]=8                             //
    a[3]= 9                             //
    fmt.Println(a, sa, sb, sc)          // -> [6 7 8 9] [6 7 8 9] [6 7] [8 9]
 
    //sb[2]=7                           // panic, although cap is 4!
 
    sb= sa                              // A copy points to the same array:
    fmt.Println(a, sa, sb)              // -> [6 7 8 9] [6 7 8 9] [6 7 8 9]
    sb[0]=0                             //
    fmt.Println(a, sa, sb)              // -> [0 7 8 9] [0 7 8 9] [0 7 8 9]
 
    // fmt.Println(sb==sa)              // invalid, works only with nil
 
    sc= append(sb, 5)                   // append() can create new array:
    fmt.Println(sa, sb, sc)             // -> [0 7 8 9] [0 7 8 9] [0 7 8 9 5]
    sa[1]= 1                            //
    sb[2]= 2                            //
    fmt.Println(sa, sb, sc)             // -> [0 1 2 9] [0 1 2 9] [0 7 8 9 5]
}

• Slices are copied by value but the internal arrays are copied by reference

more

type Point struct {
    x,y int
}
 
func main() {
    p:= Point{}
    fmt.Println(p)                      // -> {0 0}
 
    c:= p
    p.y= 1
    c.x= 2
    fmt.Println(p, c)                   // -> {0 1} {2 0}
}

func (pt *Point) Set(x,y int) {
    pt.x=x
    pt.y=y
}
 
func (pt Point) SetWithVal(x,y int) {
    pt.x=x
    pt.y=y
}
 
func main() {
    p:= Point{}
 
    /* invoking methods on an object: */
    ov:= p
    ov.SetWithVal(1,2)                  // -> SetWithVal operates only on copy!:
    fmt.Println(ov)                     // -> {0 0}
    ov.Set(3,4)                         // -> Set works as expected:
    fmt.Println(ov)                     // -> {3 4}
 
    /* invoking methods on pointer to object: */
    op:= &p
    op.SetWithVal(5,6)                  // -> SetWithVal operates only on copy!:
    fmt.Println(op)                     // -> &{0 0}
    op.Set(7,8)                         // -> Set works as expected:
    fmt.Println(op)                     // -> &{7 8}
 
    /* As expected, canges to the pointer change also the object pointed to: */
    fmt.Println(p)                      // -> {7 8}
}