Go for Javaneros (Javaïstes?)
 #go4java

Francesc Campoy
Gopher and Developer Advocate
Google
@francesc
campoy@golang.org

* What is Go?

Go is an open-source programming language

- created at Google,
- to solve Google-scale problems.

.image go4java/img/gopher.jpg 450 _

* Who uses Go?

Google:

- YouTube
- dl.google.com

Others:

- dotCloud (Docker)
- SoundCloud
- Canonical
- CloudFlare
- Mozilla
- ...

[[/wiki/GoUsers][go.dev/wiki/GoUsers]]

* Who uses Go?

.image go4java/img/trends.png _ 800

.caption Google Trends for [[http://www.google.com/trends/explore#q=golang][golang]]

* Why Go?

* Simplicity

Minimal design

.image go4java/img/perfection.jpg

* Consistency

Orthogonal features

.image go4java/img/lego.jpg 400 _

.caption By Kenny Louie from Vancouver, Canada [[http://creativecommons.org/licenses/by/2.0][CC-BY-2.0]], via Wikimedia Commons

* Readability

“The ratio of time spent reading (code) versus writing is well over 10 to 1 ... (therefore) making it easy to read makes it easier to write.”
― Robert C. Martin

.image go4java/img/piet.png 500 600

* Safety

Type safety, no buffer overflows, no pointer arithmetic.

.image go4java/img/baby.jpg 500 500

* Built-in concurrency features

“In a concurrent world, imperative is the wrong default!” - Tim Sweeney

Communicating Sequential Processes - Hoare (1978)

.image go4java/img/conc.jpg _ 1000

* Speed

.image go4java/img/fast.jpg 500 _

* Let's dive in

* Go and Java common aspects

Go and Java are

- object oriented

- garbage collected

- statically typed

- part of the C family

* Object oriented flavors

Go is Object Oriented, but doesn't have the keywords:

- `class`,
- `extends`, or
- `implements`.

* All types are created equal

* Go types

- primitive types

	int, uint, int8, uint8, ...
	bool, string
	float32, float64
	complex64, complex128

- structs

	struct {
		Name string
		Age  int
	}

- slices and arrays

	[]int, [3]string, []struct{ Name string }

- maps

	map[string]int

* Kinds of types (continued)

- pointers

	*int, *Person

- functions

	func(int, int) int

- channels

	chan bool

- interfaces

	interface {
		Start()
		Stop()
	}

* Type declarations

	type [name] [specification]

`Person` is a `struct` type.

	type Person struct {
		name string
		age  int
	}

`Celsius` is a `float64` type.

	type Celsius float64

* Function declarations

	func [name] ([params]) [return value]
	func [name] ([params]) ([return values])

A sum function:

	func sum(a int, b int) int {
		return a + b
	}

A function with multiple returned values:

	func div(a, b int) (int, int)
		return a / b, a % b
	}

Made clearer by naming the return values:

	func div(den, div int) (q, rem int)
		return a / b, a % b
	}

* Method declarations

	func ([receiver]) [name] ([params]) ([return values])

A method on a struct:

	func (p Person) Major() bool {
		return p.age >= 18
	}

But also a method on a `float64`:

	func (c Celsius) Freezing() bool {
		return c <= 0
	}

_Constraint:_ Methods can be defined *only* on types declared in the same package.

	// This won't compile
	func (s string) Length() int { return len(s) }

* Wait, pointers?

Use `&` to obtain the address of a variable.

	a := "hello"
	p := &a

Use `*` to dereference the pointer.

	fmt.Print(*p + ", world")

No pointer arithmetic, no pointers to unsafe memory.

	a := "hello"
	p := &a

	p += 4  // no, you can't

* Why pointers?

Control what you pass to functions.

- passing values, no side-effects:

	func double(x int) {
		x *= 2
	}

- passing pointers: side-effects possible:

	func double(x *int) {
		*x *= 2
	}

Control your memory layout.

- compare []Person and []*Person

* Method declarations on pointers

Receivers behave like any other argument.

Pointers allow modifying the pointed receiver:

	func (p *Person) IncAge() {
		p.age++
	}

The method receiver is a copy of a pointer (pointing to the same address).

Method calls on nil receivers are perfectly valid (and useful!).

	func (p *Person) Name() string {
		if p == nil {
			return "anonymous"
		}
		return p.name
	}

* Interfaces

* Interfaces

An interface is a set of methods.

In Java:

	interface Switch {
		void open();
		void close();
	}

In Go:

	type OpenCloser interface {
		Open()
		Close()
	}

* It's all about satisfaction

Java interfaces are satisfied *explicitly*.

Go interfaces are satisfied *implicitly*.

.image //upload.wikimedia.org/wikipedia/commons/thumb/2/29/Rolling_Stones_09.jpg/512px-Rolling_Stones_09.jpg _ 512

.caption Picture by Gorupdebesanez [[http://creativecommons.org/licenses/by-sa/3.0][CC-BY-SA-3.0]], via [[http://commons.wikimedia.org/wiki/File%3ARolling_Stones_09.jpg][Wikimedia Commons]]

* Go: implicit satisfaction

_If_a_type_defines_all_the_methods_of_an_interface,_the_type_satisfies_that_interface._

Benefits:

- fewer dependencies
- no type hierarchy
- organic composition

* Structural subtyping

Think static duck typing, verified at compile time.

.image go4java/img/duck.jpg 500 500

* FuncDraw: an example on interfaces

.image go4java/img/funcdraw.png 500 700

* FuncDraw: package parser

Package `parse` provides a parser of strings into functions.

	func Parse(text string) (*Func, error) { ... }

`Func` is a struct type, with an `Eval` method.

	type Func struct { ... }

	func (p *Func) Eval(x float64) float64 { ... }

* FuncDraw: package draw

Package draw generates images given a function.

	func Draw(f *parser.Func) image.Image {
		for x := start; x < end; x += inc {
			y := f.Eval(x)
			...
		}
	}

`draw` depends on `parser`

- makes testing hard

Let's use an interface instead

	type Evaluable interface {
		Eval(float64) float64
	}

	func Draw(f Evaluable) image.Image { ... }

* Inheritance vs composition

* Inheritance vs composition

Lots of articles have been written about the topic.

In general, composition is preferred to inheritance.

Lets see why.

* Runner

.code go4java/BadInheritance.java /START_RUNNER/,/END_RUNNER/

* RunCounter is-a Runner that counts

.code go4java/BadInheritance.java /START_COUNTING/,/END_COUNTING/

* Let's run and count

What will this code print?

.code go4java/BadInheritance.java /START_MAIN/,/END_MAIN/

Of course, this prints:

	running one
	running two
	running three
	my runner ran 6 tasks

Wait! How many?

* My runner ran 6 tasks? Six?

Inheritance causes:

- weak encapsulation,
- tight coupling,
- surprising bugs.

.image go4java/img/badinheritance.png

* Solution: use composition

.code go4java/Composition.java /START_COUNTING/,/BREAK_COUNTING/

* Solution: use composition (continued)

.code go4java/Composition.java /BREAK_COUNTING/,/END_COUNTING/

* Solution: use composition (continued)

*Pros*

- The bug is gone!
- `Runner` is completely independent of `RunCounter`.
- The creation of the `Runner` can be delayed until (and if) needed.

*Cons*

- We need to explicitly define the `Runner` methods on `RunCounter`:

	public String getName() { return runner.getName(); }

- This can cause lots of repetition, and eventually bugs.

* There's no inheritance in Go

* There's no inheritance in Go

Let's use composition directly:

# .code go4java/runner/runner.go /type Task/,/END_TASK/

.code go4java/runner/runner.go /type Runner/,/END_RUNNER/

All very similar to the Java version.

* RunCounter

`RunCounter` has a `Runner` field.

.code go4java/runner/runner.go /type RunCounter/,

* Composition in Go

Same pros and cons as the composition version in Java.

We also have the boilerplate to proxy methods from `Runner`.

.code go4java/runner/runner.go /runner.Name/

But we can remove it!

* Struct embedding

Expressed in Go as unnamed fields in a struct.

It is still *composition*.

The fields and methods of the embedded type are defined on the embedding type.

Similar to inheritance, but the embedded type doesn't know it's embedded.

* Example of struct embedding

Given a type `Person`:

.code go4java/embedsample.go /Person/,/Hi/

We can define a type `Employee` embedding `Person`:

.code go4java/embedsample.go /Employee/,/}/

All fields and methods from `Person` are available on `Employee`:

.code go4java/embedsample.go /var/,/Introduce/

* Struct embedding

.code go4java/runner/embed.go /type RunCounter2/,

* Is struct embedding like inheritance?

No, it is better!

It is composition.

- You can't reach into another type and change the way it works.

- Method dispatching is explicit.

It is more general.

- Struct embedding of interfaces.

* Is struct embedding like inheritance?

Struct embedding is selective.

.code go4java/writecounter.go /WriteCounter/,/MAIN/

WriteCounter can be used with any `io.ReadWriter`.

.play go4java/writecounter.go /func main/,/^}/

* Easy mocking

What if we wanted to fake a part of a `net.Conn`?

	type Conn interface {
	        Read(b []byte) (n int, err error)
	        Write(b []byte) (n int, err error)
	        Close() error
	        LocalAddr() Addr
	        RemoteAddr() Addr
	        SetDeadline(t time.Time) error
	        SetReadDeadline(t time.Time) error
	        SetWriteDeadline(t time.Time) error
	}

I want to test `handleCon`:

.code go4java/loopback.go /handleCon/

- We could create a `fakeConn` and define all the methods of `Conn` on it.

- But that's a lot of boring code.

* Struct embedding of interfaces

_WARNING_:_Cool_stuff_

If a type T has an embedded field of a type E, all the methods of E will be defined on T.

Therefore, if E is an interface T satisfies E.

* Struct embedding of interfaces (continued)

We can test `handleCon` with the `loopBack` type.

.code go4java/loopback.go /loopBack/,/^}/

Any calls to the methods of `net.Conn` will fail, since the field is nil.

We redefine the operations we support:

.code go4java/loopback.go /Read/,

* Concurrency

* Concurrency

It is part of the language, not a library.

Based on two concepts:

- goroutines: lightweight threads
- channels: typed pipes used to communicate and synchronize between goroutines

So cheap you can use them whenever you want.

.image go4java/img/funnelin.jpg 300 700

* Sleep and talk

.code go4java/conc1.go /sleepAndTalk/,/^}/

We want a message per second.

.play go4java/conc1.go /func main/,/^}/

What if we started all the `sleepAndTalk` concurrently?

Just add `go`!

* Concurrent sleep and talk

.play go4java/conc2.go /func main/,/^}/

That was fast ...

When the `main` goroutine ends, the program ends.

* Concurrent sleep and talk with more sleeping

.play go4java/conc3.go /func main/,/^}/

But synchronizing with `Sleep` is a bad idea.

* Communicating through channels

`sleepAndTalk` sends the string into the channel instead of printing it.

.code go4java/chan.go /sleepAndTalk/,/^}/

We create the channel and pass it to `sleepAndTalk`, then wait for the values to be sent.

.play go4java/chan.go /func main/,/^}/

* Let's count on the web

We receive the next id from a channel.

.code go4java/goodcounter.go /nextID/,/^}/

We need a goroutine sending ids into the channel.

.play go4java/goodcounter.go /func main/,/^}/

[[http://localhost:8080/next]]

* Let's fight!

`select` allows us to chose among multiple channel operations.

.play go4java/battle.go /battle/,/^}/

Go - [[http://localhost:8080/fight?usr=go]]
Java - [[http://localhost:8080/fight?usr=java]]

* Chain of gophers

.image go4java/img/chain.jpg

Ok, I'm just bragging here

* Chain of gophers

.play go4java/goroutines.go /func f/,

* Concurrency is very powerful

And there's lots to learn!

- [[/talks/2012/concurrency.slide#1][Go Concurrency Patterns]], by Rob Pike
- [[/talks/2013/advconc.slide#1][Advanced Concurrency Patterns]], by Sameer Ajmani
- [[/talks/2012/waza.slide#1][Concurrency is not Parallelism]], by Rob Pike

.image go4java/img/busy.jpg

* In conclusion

Go is simple, consistent, readable, and fun.

All types are equal

- methods on any type

Implicit interfaces

- Structural typing
- Less dependencies
- Code testable and reusable

Use composition instead of inheritance

- Struct embedding to remove boilerplate.
- Struct embedding of interfaces to satisfy them fast.

Concurrency is awesome, and you should check it out.

* What to do next?

Learn Go on your browser with [[/tour/][go.dev/tour]]

Find more about Go on [[/][go.dev]]

Join the community at [[https://groups.google.com/forum/#!forum/Golang-nuts][golang-nuts]]

Link to the slides [[/talks/2014/go4java.slide]]