Introduction to Programming in Go

Introduction to Programming in Go
Amr Hassan

Apologies
This might feel very rudimentary to you.
But this is an "introduction" after all.

In the beginning... Go was created by those guys

Original intentions
Go has always been intended as a systems programming language (way at the bottom of the application
development stack).
In systems programming you would usually use C/C++ or Python if performance is not an issue for you as
productivity is.

Original intentions
Born out of mutual hatred towards writing and compiling C++ code.
To the surprise of the creators, Go has seen a much higher rate adoption from the scripting crowd
(Python and Ruby), and most of the C/C++ people perceived the simplicity of the langauge as a step back.

Where it is now
Seemingly everywhere
Go is 5 years old now.
To the surprise of its creators, it has grown tremendously in popularity.
It's the new go-to platform for building cloud infrastructure.

Where it is now
List of Go users(https://github.com/golang/go/wiki/GoUsers)

What Go isn't
Let's start by dialing down your expectations to a manageable level.

Go isn't a functional programming langauge
Although functions are first class objects
Go's adopted style is imperative through and through (sort of like C).
Your code is executed for its side effects, and you reason about your logic as sequential commands
executed to mutate some value within your scope of action.
Purely functional idioms in Go are really counter-productive.
So if you're a functional programming hipster, get over it.

Go isn't an object-oriented language
Although Go has objects.. with methods
And a limited way of doing inheritance (it's actually called composition)
It's not OOP-driven, and won't scratch your pure OOP itch.
Trying to construct rich type hierarchies like in Java or Python is very counter-productive.

Go isn't a high-level language
You might think that's implicit with "systems language", but it isn't. (cough) (Rust) (cough)
Go favors readability above all.
Go Offers just enough syntactic sugar to be productive, but not too much.
That is why a lot of the times verbosity and code simplicity are favored over complex succinctness.

What Go is
Hopefully I haven't lost you yet.

Go is Compiled
Compiles to native hardware instructions that can run on the bear metal.
No overhead of a VM or an interpreter.
Comes at the price of doing cross-compilation when you need multiple OS support.
Don't worry, most of the stdlib is cross-compatible.

Go executables are statically-linked
Storage is cheap!
External dependencies and shared binaries are not worth the effort.

Go executables are statically-linked
Very attractive feature right now.

Go is statically-typed (awesomeness)
As you may know, I’m a bit biased towards static typing.
I just think it’s a really neat idea as it makes my life a lot easier.

Go is statically-typed
What is static typing anyway?
Unfortunately static typing has always had this stigma of it being too verbose.
This is not the case anymore in modern languages like Go, because of type inference.
So you kind of get the best of both worlds there.

Go is memory-managed
Go runtime is responsible for allocating memory for your objects.
You never need to worry about the correct (or incorrect) number of bytes to allocate.
Heap, stack or data segments are all fine with you.

Go has a tracing garbage collector.
You never need to worry about who will deallocate your memory when.
You just use objects, pass them around and then stop using them.

Unlike many other memory-managed programming languges, Go has memory pointers.
But since pointer arithmetic is unallowed (easily), it's considered safe.
Go is pragmatic
Built by software engineers (not academics) out of specific programming use cases, not in a "lab" or by
language designers.
Covers most of the areas that the creators felt needed addressing in their day-to-day programming
dendeavours.

Go is minimalistic
Small set of orthogonal features that provide a a sweet spot balance between programmer productivity
and simple software design.
Implies:
- Gentle learning curve
- Human-readable source code
It’s very common for people to pick up the language in an afternoon and start building things
immediately
Huge plus!

Go is modern
As a fairly-new language, the stdlibs come with packages for doing many of the essential jobs that a
programmer in this day would most likely require in her job.
Integrated web development stack and testing tools in the std libs and toolachain.
So no excuse to not be test-driven!

Go is concurrent
Dubbed a "concurrent language" because of support for native building blocks of concurrency built into
the syntax
Go's concurrency building blocks allow you to
- write and execute code concurrently directly from the language syntax
- establish managed (and safe) ways for communicating between concurrently executing code

Go is concurrent
The Go runtime will multiplex your concurrent code for you on actual OS threads, free of charge.

Go is a bit frustrating at first
First impressions of Go is that it's very lacking.
Go is almost never anyone’s first programming language, so everyone comes to it with expectations and
biases about how things should be done according to their system of belief and the kind of programming
idiom they are used to.
Since that Go was built out of frustration with the current state of things, it's meant to disrupt the way you
program.

Go is a bit frustrating at first
You shouldn't give into that initial frustration.
Because it gets rewarding very quickly.

Syntax
Most of these examples are derived from the official tour of Go on golang.org.
So if they seem too familiar, that’s probably the reason.

Syntax: Hello World
Execution starts in the main() in the "main" package.
UTF-8 source code files. No special headers. No literal escaping.
You can even declare unicode symbols.
Ω(DoSomething()).Should(Equal("foo"))
You probably shouldn't do that. Nice to know that you can though.
"fmt" is where you find string formatting functions.
"fmt" name is Rob Pike's doing.
package main
import "fmt"
func main() {
fmt.Println("Hello, ‫ﻳﺎ‬‫ﺑﺸﺮ‬ ")
} Run

Syntax: Variables
Variables can be declared in function scope of package scope.
package main
import "fmt"
var c, python, java bool
func main() {
var i int
fmt.Println(i, c, python, java)
} Run

Syntax: Variables with initializers
Type inference in action!
package main
import "fmt"
var i, j int = 1, 2
func main() {
var c, python, java = true, false, "no!"
fmt.Println(i, j, c, python, java)
} Run

Syntax: Shorthand variable declaration
Only inside a function body.
Both declarations are identical.
package main
import "fmt"
func main() {
var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java)
} Run

Syntax: Primitive types
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64
complex64 complex128
and
byte // alias for uint8
rune // alias for int32 and it represents a Unicode code point
Zero values for booleans is false and for numerical types an actual 0.

Syntax: Primitive types in action
package main
import (
"fmt"
"math/cmplx"
)
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
func main() {
const f = "%T(%v)n"
fmt.Printf(f, ToBe, ToBe)
fmt.Printf(f, MaxInt, MaxInt)
fmt.Printf(f, z, z)
} Run

Syntax: Type Conversion
Unlike in a lot of other languages where automatic conversion to types with wider percision is allowed,
type conversions in Go must be explicit.
The expression T(v) converts the value v to the type T.
package main
import (
"fmt"
"math"
)
func main() {
var x, y int = 3, 4
var f float64 = math.Sqrt(float64(x*x + y*y))
var z int = int(f)
fmt.Println(x, y, z)
} Run

Syntax: Loops
Your for-s, foreach-es, and your while-s.

Syntax: Loops - For Loop
Very C.
Parens are not allowed. Not even optional!
Body brakcets are obligatory.
package main
import "fmt"
func main() {
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
fmt.Println(sum)
} Run

Syntax: Loops - For Loop
package main
import "fmt"
func main() {
sum := 1
for ; sum < 1000; {
sum += sum
}
fmt.Println(sum)
} Run

Syntax: Loops - While Loop
package main
import "fmt"
func main() {
sum := 1
for sum < 1000 {
sum += sum
}
fmt.Println(sum)
} Run

Syntax: While (TRUE) Loop
package main
import (
"fmt"
"time"
)
func main() {
for {
fmt.Println("Tick!")
time.Sleep(1000)
fmt.Println("Tock!")
time.Sleep(1000)
}
} Run

Syntax: Conditionals - If
Also very C.
Also body brakcets are obligatory
Again, parens are not even optional.
package main
import (
"fmt"
"math"
)
func sqrt(x float64) string {
if x < 0 {
return sqrt(-x) + "i"
}
return fmt.Sprint(math.Sqrt(x))
}
func main() {
fmt.Println(sqrt(2), sqrt(-4))
} Run

Syntax: Conditionals - If with pre-statement
package main
import (
"fmt"
"math"
)
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
}
return lim
}
func main() {
fmt.Println(
pow(3, 2, 10),
pow(3, 3, 20),
)
} Run

Syntax: Conditionals - If/else
package main
import (
"fmt"
"math"
)
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
} else {
fmt.Printf("%g >= %gn", v, lim)
}
// can't use v here, though
return lim
}
func main() {
fmt.Println(
pow(3, 2, 10),
pow(3, 3, 20),
)
} Run

Syntax: Conditionals - Switch
Switch is a fancy if with multiple if/else clauses.
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Print("Go runs on ")
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
// freebsd, openbsd,
// plan9, windows...
fmt.Printf("%s.", os)
}
} Run

Syntax: Conditionals - Switch case evaluation
switch i {
case 0:
case f():
}
The evaluation order of the switch case statements happens from top to bottom.

Syntax: Functions
The main building block in Go.
You can create nested closures using the func keyword.
package main
import "fmt"
func add(a int, b int) int {
return a + b
}
func main() {
sum := add(3, 1)
fmt.Println("Initial sum", sum)
// Closures! and first-class function values
incrementSum := func() { sum += 1 }
incrementSum()
incrementSum()
fmt.Println("Incremented sum", sum)
} Run

Syntax: Functions
The type of function values is:
func([argument_list]) [return_type]

Syntax: Higher order functions
We can use function types to declare some higher order functions like
package main
import "fmt"
func add(a int, b int) int { return a + b }
func subtract(a, b int) int { return a - b }
func execute(a, b int, operation func(int, int) int) int { // shorthand for duplicate types
return operation(a, b)
}
func main() {
i, j := 4, 2
added := execute(i, j, add)
fmt.Printf("Added %d + %d == %dn", i, j, added)
subtracted := execute(i, j, subtract)
fmt.Printf("Subtracted %d - %d == %dn", i, j, subtracted)
} Run

Syntax: Defer
An awesome Go-first!
Push clean-up code to be executed before the function returns in LIFO.
Go's way of making up for not managing resources for you other than memory and CPU.
package main
import "fmt"
func main() {
defer fmt.Println("world")
fmt.Println("hello")
} Run

Syntax: Stacking defer statements
package main
import "fmt"
func main() {
fmt.Println("counting")
for i := 0; i < 10; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
} Run

Syntax: Pointers
A Go pointer value is nothing but a typed memory addresses, much like a C pointer.
*T is a pointer to a T value
The zero value of a pointer is nil (no garbage values in Go).

Syntax: Pointers
This is how you declare a pointer.
var p *int
The & operator generates a pointer to its operand.
i := 42
p = &i
The * operator denotes the pointer's underlying value.
fmt.Println(*p) // read i through the pointer p
Dereferencing a pointer is also via the * operator.
*p = 21 // set i through the pointer p
Unlike C, Go has no pointer arithmetic.

Syntax: Structs
The the way of building heterogeneous aggregate custom types in Go.
That's fancy talk for saying it's a collection of fields of different types.
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
fmt.Println(Vertex{1, 2})
} Run

Syntax: Structs
Struct fields are accessible using the dot notation
package main
import "fmt"
X int
Y int
}
func main() {
v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X)
} Run

Syntax: Struct literal notation
package main
import "fmt"
X, Y int
}
var (
v1 = Vertex{1, 2} // has type Vertex
v2 = Vertex{X: 1} // Y:0 is implicit
v3 = Vertex{} // X:0 and Y:0
p = &Vertex{1, 2} // has type *Vertex
)
func main() {
fmt.Println(v1, p, v2, v3)
} Run

Syntax: Pointers to structs
Quickly instantiate and populate with values a struct all at once
package main
import "fmt"
X int
Y int
}
func main() {
v := Vertex{1, 2}
p := &v
p.X = 1e9
fmt.Println(v)
} Run

Syntax: Structs are your main objects
If you’re coming from a strictly OOP language like Java, the only thing you would be thinking about in your
program design, is classes.
Classes this, classes that, classes everywhere.

Syntax: Structs are your main objects
Go creators did not like that approach where everything had to be a class.
Sometimes, the simplest most correct way to express your computation, is just as a function.
Go fell back to the minimalistic approach of C, where your data structures are just pure aggregate data.
And you can as an added bonus, you can specify type-specific operations on each of your custom types.
It’s like how in C you would declare struct s and then declare functions that all accept a pointer to the
struct as their first argument by convention.

Syntax: Struct methods
Two argument lists. First one only has the "receiver" argument. Second one has zero or more argumetns
of your method.
Dot notation for invoking struct methods on the receiver.
package main
import ("fmt"; "math")
type Vector struct {
X float64
Y float64
}
func (v Vector) Magnitude() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) }
func (v *Vector) Add(other *Vector) *Vector { return &Vector{X: v.X + other.X, Y: v.Y + other.Y} }
func main() {
vec := Vector{3.0, 4.0}
fmt.Println(vec)
fmt.Println(vec.Magnitude())
fmt.Println(vec.Add(&Vector{6.0, 4.0}))
} Run

Syntax: Arrays
The way of constructing homogeneous aggregate types in Go (a sequence of values of the same type).
Analogous to boring C arrays.
Fixed in size.
Size is part of the type.
package main
import "fmt"
func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)
} Run

Syntax: Slices
Slices are arrays on steroids.
Go makes up for the fact that it doesn’t let you do pointer arithmetic, by giving you this much cooler and
easier to use concept of slices.
A slice is more or less a view into a subset of an array.
[]T is a slice with elements of type T.
A slice's size is not reflected in its type.

Syntax: Slices
The slice literal notation lets you create slices backed by anonymous arrays very easily and populate them
with values on the spot.
Slices are used just like you would use an array, except for a couple of extra very neat features.
package main
import "fmt"
func main() {
p := []int{2, 3, 5, 7, 11, 13}
fmt.Println("p ==", p)
for i := 0; i < len(p); i++ {
fmt.Printf("p[%d] == %dn", i, p[i])
}
} Run

Syntax: Slicing slices
You can slice slices!
Very similar to sequence slicing in Python (except that negative indices are not supported).
You can slice into a slice to get a new view into its backing array, or you can slice into an already existing
array to get a slice from that.
package main
import "fmt"
func main() {
p := []int{2, 3, 5, 7, 11, 13}
fmt.Println("p ==", p)
fmt.Println("p[1:4] ==", p[1:4])
// missing low index implies 0
fmt.Println("p[:3] ==", p[:3])
// missing high index implies len(s)
fmt.Println("p[4:] ==", p[4:])
} Run

Syntax: Slicing slices
The zero value of a slice is nil.

Syntax: Appending to slices
package main
import "fmt"
func main() {
var a []int
printSlice("a", a)
// append works on nil slices.
a = append(a, 0)
printSlice("a", a)
// the slice grows as needed.
a = append(a, 1)
printSlice("a", a)
// we can add more than one element at a time.
a = append(a, 2, 3, 4)
printSlice("a", a)
}
func printSlice(s string, x []int) {
fmt.Printf("%s len=%d cap=%d %vn",
s, len(x), cap(x), x)
} Run

Syntax: Appending to slices
If the backing array of the slice is too short, then append() would create a new backing array big enough
and use that in the returned slice.

Syntax: Maps
The native type-safe associative array in Go is the hash map, almost identical to the native map type in
Python.

Syntax: Maps
You must create a map using the make() function before usage, because the zero value of map is nil and
using that as a map causes in an error.
You can create maps from any type to any type.
package main
import "fmt"
Lat, Long float64
}
var m map[string]Vertex
func main() {
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
40.68433, -74.39967,
}
fmt.Println(m["Bell Labs"])
} Run

Syntax: Map Literals
package main
import "fmt"
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
func main() {
fmt.Println(m)
} Run

Syntax: Map operations
package main
import "fmt"
func main() {
m := make(map[string]int)
m["Answer"] = 42
fmt.Println("The value:", m["Answer"])
m["Answer"] = 48
delete(m, "Answer")
v, exists := m["Answer"]
fmt.Println("The value:", v, "Present?", exists)
} Run

Syntax: Range loops
21st century looping in Go
Similar to Python sequence looping
for i, v in enumerate([1, 2, 3])
and map looping
for k, v in mapping.items()
package main
import "fmt"
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
for i, v := range pow {
fmt.Printf("2**%d = %dn", i, v)
}
} Run

The Zen of Go: Interfaces
Go resists this:
- subtype polymorphism (inheritance).
- parametric-type polymorphism (generics).
It instead emphasizes polymorphism via interfaces.

Go interfaces are small.
type Stringer interface {
String() string
}
A Stringer can pretty print itself.
Anything that implements String is a Stringer.
Interfaces are implemented implicitly.

Interfaces are types.
package main
import "fmt"
type Named interface {
Name() string
}
func greet(someone Named) { fmt.Println("Greetings, " + someone.Name()) }
type Human struct {
firstName string
}
func (h Human) Name() string {
return h.firstName
}
func main() {
greet(Human{firstName: "Jack Bauer"})
} Run

A Sorting example
package main
import ("fmt"; "sort")
type Person struct {
Name string
Age int
}
func (p Person) String() string { return fmt.Sprintf("%s: %d", p.Name, p.Age) }
// ByAge implements sort.Interface for []Person based on
// the Age field.
type ByAge []Person
func (a ByAge) Len() int { return len(a) }
func (a ByAge) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func main() {
people := []Person{{"Bob", 31}, {"John", 42}, {"Michael", 17}, {"Jenny", 26}}
fmt.Println(people)
sort.Sort(ByAge(people))
fmt.Println(people)
} Run

The Zen of Go: Error handling
Unchecked exceptions are evil.
This is not scripting. You're building "robust" infrastructure software.
"Let it crash" cannot be the default way of handling errors.
Every computation that can fail must be executed with proper "error handling code".

Memorize this pattern. You're gonna use it so much it'll haunt you in your dreams.
package main
import (
"fmt"
)
func getMyText() (string, error) {
// This could have been read from disk or a network socket
return "Your text", nil
}
func main() {
myText, err := getMyText()
if err != nil {
myText = "Sorry, I couldn't get your text. May I interest you in a joke?"
}
fmt.Println(myText)
} Run

Go chose simplest approach possible to error handling.
Errors are plain regular values that implement the error interface.
type error {
Error() string
}
You should either handle an error or propagate it upwards.

Unexpected errors should not be expected
package main
import ("fmt"; "regexp")
func extractLongestNumber(text string) string {
extractorRegexp, err := regexp.Compile("([0-9]+)")
if err != nil {
panic(err) // This will crash with a stack trace and the value of err
}
matches := extractorRegexp.FindStringSubmatch(text)
if len(matches) > 1 { return matches[1] } else { return "" }
}
func main() {
myText := "Sonmi-451"
fmt.Println(extractLongestNumber(myText))
} Run

This is so common that there's a pattern for it.
package main
import ("fmt"; "regexp")
func extractLongestNumber(text string) string {
extractorRegexp := regexp.MustCompile("([0-9]+)")
matches := extractorRegexp.FindStringSubmatch(text)
if len(matches) > 1 { return matches[1] } else { return "" }
}
func main() {
myText := "Sonmi-451"
fmt.Println(extractLongestNumber(myText))
} Run

Having to handle every each possible error case manually is a common first-day complaint in Go
You get used to it very quickly.
You will definitely feel its reward when you run your code and find it correct and not crashing the first
time.

The Zen of Go: Packages
Packages are one more thing that newcomers clash against.
Go comes with its own way of doing packages and file hierarchy for source code.
Just stop fighting it.

The Zen of Go: Packages
The first thing you'll do after installing the Go SDK is setting up your $GOPATH.
$GOPATH is structured like so:
|- src
|- bin
|- pkg
The import path of your packages is going to be the relative path under your $GOPATH/src directory.
Doing
import "coderize/awesomelib"
imports the package from $GOPATH/src/coderize/awesomelib as the awesomelib package
It's as simple as that. Don't invent your own system.

The Zen of Go: Visibility
Code visibility is only on the package level.
Only symbols starting with an upper class letter are exported.
package awesomelib
type ExportedType interface {
PublicAction()
}
type internalType struct {
internalNumber int
}
func (a internalType) PublicAction() { /* I work in silence*/ }
func internalDityWork() { /* TMI*/ }
func NewAwesomeness() ExportedType { /* TMI*/ return internalType{internalNumber: 42} }

The Zen of Go: Documentation
No special syntax.
Code documentation should be readable to humans in source code text format.
// Accepts an io.Reader and does the agreed-upon computation and returns the result
// or a descriptive error if something went wrong.
func ExportedFunction(reader io.Reader) (Result, error)
No special markup tags to describe parameters or return types.
If you make sure all your exported symbols are documented, Godoc can render that into perfectly
presentable HTML for you.
godoc(http://godoc.org/)

The Zen of Go: Concurrency
I've saved the best for last.
Concurrency is a session topic on its own.
Let's just skim over of what Go has to offer.

A goroutine is a lightweight thread managed by the Go runtime.
Go routines are multiplexed over multiple actual OS threads by the runtime.
go f(x, y, z)
starts a new goroutine running
f(x, y, z)

package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go say("world")
say("hello")
} Run

A channel is a typed synchronized queue.
boolChannel := make(chan bool) // I created a boolean channel of type "chan bool"
Channels are utilized for communication and synchronization between running goroutines.
There are three things you can do on a channel: send stuff, receive stuff, or close the channel.
boolChan <- = false
boolChan <- = true
boolChan <- = true
close(boolChan)
I just sent a "false" and two "true"s to the channel then closed it.

On the receiving end:
// Listens on the given channel for three incoming boolean messages and returns true if any one
// was true
func getMyBooleans(myChannel chan bool) bool {
firstMessage, isOpen := <- boolChan
if !isOpen {
return false
}
secondMessage, isOpen := <- boolChan
if !isOpen {
return firstMessage
}
thirdMessage, isOpen := <- boolChan
if !isOpen {
return firstMessage | secondMessage
}
return firstMessage | secondMessage | thirdMessage
}

Too verbose? range to the rescue:
// Listens on the given channel for incoming boolean messages and returns true if any one
// was true
func getMyBooleans(myChannel chan bool) bool {
message := false
for incomingMessage := myChannel {
message |= incomingMessage
}
return message
}

Channel sends and receives are blocking operations. So they're perfect for doing "lock-free"
synchronization.

Here's a really dumb example that takes too much time to compute
package main
import "fmt"
func fibonacci(i uint) uint {
if i <= 1 {
return 1
}
return fibonacci(i-1) + fibonacci(i-2)
}
func main() {
fmt.Println(fibonacci(41))
fmt.Println(fibonacci(41))
} Run

Same example but now made faster using parallelism via goroutines and channels.
package main
import "fmt"
func compute(computation func() int) <- chan int {
outputChannel := make(chan int)
go func() {
outputChannel <- computation()
}()
return outputChannel
}
func fibonacci(i int) int { if i <= 1 { return 1 } else {return fibonacci(i-1) + fibonacci(i-2) }}
func main() {
computation := func() int {return fibonacci(41)}
firstResult := compute(computation)
secondResult := compute(computation)
// Now I'm gonna block and wait for the two results
fmt.Println(<- firstResult)
fmt.Println(<- secondResult)
} Run

Where to Go from here (pun intended)

Where to Go from here (pun intended)
There are still several things that I did not have the time to cover in Go.
I suggest checking out the links below.
Take the Go tour yourself(http://tour.golang.org/)
Go for Gophers (by Andrew Gerrand)(https://talks.golang.org/2014/go4gophers.slide)
Go Concurrency Patterns (by the awesome Rob Pike)(https://www.youtube.com/watch?feature=player_detailpage&v=f6kdp27TYZs)
Go subreddit(http://www.reddit.com/r/golang)

Introduction to Programming in Go

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Introduction to Programming in Go

Similar to Introduction to Programming in Go (20)

Recently uploaded

Recently uploaded (20)

Introduction to Programming in Go