talk.slide

Golang in an hour
A talk for Torino Coding Society
11 May 2015

Gianfranco Reppucci
Software developer, Qurami
gianfranco.reppucci@qurami.net
http://qurami.com
@giefferre


* Hello World!

.image img/giefferre.jpg 250 _

- Software developer [[http://qurami.com][@Qurami]]
- Founder [[http://meetup.com/AppsterdamMilan][@AppsterdamMilan]]
- Golang developer & enthusiast


* Disclaimer

Code crusaders? No, thanks

.image img/codecrusader.jpg 400 _


* Agenda

- Introduction
- Basics
- Go is about composition
- Parallelism and synchronization
- What I learned
- Tips & Tricks
- Reference


* Introduction


* Development evolution

- From _monolithic_code_ to _microservices_
- From "all-inclusive frameworks" to bootstrapping frameworks with dependency managers
- From C to ?


* Context

- There is a lot of different programming languages available to developers
- Some of them are pretty easy, some others have great performances
- We can find frameworks, plugins and extensions for each of them


* 

.image img/indiana.jpg 520 _


* Start using something modern

.image img/gopher_yellow.png 300 _

.caption *Go*is*an*open*source*programming*language*
.caption *that*makes*it*easy*to*build*simple,*reliable*and*efficient*software.*
.caption quote from golang.org


* History

- *2007*: first experiment
- *2009*: public launch
- *2011*: integration in Google App Engine
- *2012*: release of version 1
- *2015*: support for mobile devices _(_v._>=_1.5)_


* Key points

- Strongly typed language, featuring advanced tools
- Absolutely genuine: syntax and environments are similar to dynamic languages
- Performance driven
- It's open sourced, it is secure


* Batteries included

- Lightweight runtime components (garbage collector, scheduler, etc.)
- Two compilers (gc or gccgo)
- Plenty of standard libraries
- Documentation
- Formatter


* Formatter

From this...

.image img/code_mess.png 200 _

To this :)

.image img/code_clean.png 200 _


* 

.image img/biplane.jpg 300 _

.caption *Go*sits*somewhere*between*C*and*Python.*
.caption *It*has*the*static*type*checking*and*bit-twiddling*powers*of*C,*
.caption *yet*much*of*the*speed*of*development*and*conciseness*of*Python*
.caption quote from Graham King


* Basics

* First things first

.play code/helloworld.go


* First things first (cont.)

.code code/helloworld.go

- _package_ determines the namespace
- it CANNOT be omitted
- if you are not writing a package, it shall be *main*


* First things first (cont.)

    import "fmt"

 

    import (
        "fmt"
        "net/http"
        "code.google.com/p/goconf/conf"
        "github.com/garyburd/redigo/redis"
    )

- _import_ loads one or more packages
- packages could be imported even remotely, from Googlecode or Github


* First things first (cont.)

.code code/helloworld.go

- fmt is a _formatting_ library


* Variables and scope

.code code/variables.go /START2/,/STOP2/

is equivalent to:

.code code/variables.go /START1/,/STOP1/

Check it out:

.play code/variables.go /START3/,/STOP3/


* Variables and scope (cont.)

Be aware of the scope!

.play code/scope.go /START1/,/STOP1/


* Methods

Methods are declared with the keyword *func* as follows:

.play code/methods.go /START1/,/STOP1/


* Error handling

There is no exception, only errors

    file, err := os.Open(filePath)
    if err != nil {
        return err
    }

    codeUsing(file)

If you forget to handle and error, the application will probably crash!

* Go is about composition

* Structs

While Java or C are about _inheritance_, Go is about _composition_

Go is Object Oriented, but not in the usual way

In fact:
- No class inheritance
- No method or operator overloading
- No circular dependencies among packages


* 

.image img/zak.jpg 520 _


* The Person struct

Let's define the struct _Person_

.code code/structs.go /START1/,/STOP1/

With its own methods...

.code code/structs.go /START2/,/STOP2/


* The Person struct (cont.)

And of course a constructor-like factory method:

.code code/structs.go /START3/,/STOP3/


* The Person struct (cont.)

We'll use the struct Person as follows:

.code code/structs.go /START7/,/STOP7/
.code code/structs.go /START8/,/STOP8/


* 

.image img/bernard.png 520 _


* The Student struct

Let's *compose* a new struct _Student_ by using the previous struct:

.code code/structs.go /START4/,/STOP4/
.code code/structs.go /START5/,/STOP5/


* The Student struct (cont.)

And constructor as usual:

.code code/structs.go /START6/,/STOP6/


* Putting it all together

As simple as that:

.play code/structs.go /START9/,/STOP9/


* Parallelism and synchronization


* 

.image img/parallelism.jpg 520 _


* Goroutines

A _goroutine_ is a lightweight thread.

To launch a goroutine, use the *go* keyword before a function.

.play code/goroutines.go /START1/,/STOP1/


* Goroutines (cont.)

Goroutines can also use anonymouse methods

.play code/goroutines_anon.go /START1/,/STOP1/


* Channels

Channels allow you to pass data between running goroutines.

They can be _buffered_ or _unbuffered_.

You can build a channel from any kind of data structure!

    ch := make(chan int)

    // insert a value into the channel
    ch <- 5

    // read data from the channel
    var readValue int
    readValue = <-ch

    // readValue is 5


* The beacon

.play code/channels.go /START1/,/STOP1/


* Select

The _select_ statement is like a switch statement, but it selects over channel operations using a first-come, first-served logic.

It is useful to implement synchronization!


* The beacon, using select

.play code/select.go /START1/,/STOP1/


* What I learned


* PROs

- Explicit is better than implicit: Go code is _really_readable_
- Concurrency is super-easy
- Your application ships within a single binary file - no extra dependencies!
- Your application runs on (almost) any platform


* Warnings

- Be aware of error handling
- Sometimes you'll write real "low-level" code


* CONs

No generics, sorry!

There are two ways to decode JSON, XML or objects in other formats to Golang structs:

- If you know the exact model, via the _Unmarshal_ method
- If you don't know the attributes of your model, do _type_assertion_


* CONs (cont.)

Package versioning is not handled at all :(

An update of a remote package could break compatibility!

Your application will not build anymore


* From an entrepreneur's point of view

- The language is born and supported from Google
- [[https://github.com/golang/go/wiki/GoUsers][The list of Golang users is growing up extremely fast]], you're not alone
- The learning curve is quite high, but you'll have better programmers


* Tips & Tricks 


* Test suite

Care about *TDD* (_you_should!_)?

You can use the *go*test* native tool, or use a more advanced suite like *Goconvey*

Project site is [[http://goconvey.co]]


* Installing multiple Go versions

Do you need to use different versions of Go?

Do not mess your environment, use the *Go*Version*Manager* tool!

Instructions are available at [[https://github.com/moovweb/gvm]]


* Want to create a keynote like this?

Use the *present* tool!

It is a native golang solution, available as a package, to run slides and code within your browser.

Check it out at [[https://godoc.org/golang.org/x/tools/present]]


* Golang hands on, within your browser

Start using Go easily!

Point your browser to [[http://play.golang.org]].

.image img/playground.png 400 _


* Check this keynote later

Bookmark this address

[[http://go-talks.appspot.com/github.com/giefferre/golang-in-an-hour/talk.slide]]


* Reference

.link http://reneefrench.blogspot.com The gopher images, by Renee French
.link http://matt.aimonetti.net/posts/2013/08/27/what-technology-should-my-startup-use What technology should my startup use?, by Matt Aimonetti
.link http://www.darkcoding.net/software/go-lang-after-four-months/ Go after four months, by Graham King
.link http://blog.iron.io/2013/03/how-we-went-from-30-servers-to-2-go.html How we went from 30 servers to 2, by Travis Reeder
.link http://blog.iron.io/2013/08/go-after-2-years-in-production.html Go after 2 years in production, by Travis Reeder
.link http://www.slideshare.net/jpetazzo/docker-and-go-why-did-we-decide-to-write-docker-in-go Docker and Go: why did we decide to write docker in Go?


* 

.image img/the_end.jpg 520 _