go101.slide

Go

Ignacio Ríos Vazquez
Hexacta
ivazquez@hexacta.com
http://www.hexacta.com

* Agenda

Introducción, objetivos e historia

Sintaxis, tipos de datos

Concurrencia

Patrones de concurrencia

* Introducción

* ¿Por qué un nuevo lenguaje?
Hace años que no surgen nuevos lenguajes para el desarrollo de software de sistema (software de base).

Escribir software es muy difícil, hay que elegir entre eficiencia de compilación, eficiencia de ejecución o facilidad de programación. Ningún lenguaje de los más usados posee las tres.

.image go101/img/sadgopher.png _ 250

* Tendencias
- Las computadoras son más rápidas.
- La administración de dependencias es más compleja.
- Los programadores eligen facilidad antes que eficiencia y prefieren lenguajes interpretados (JavaScript, Python, Ruby).
- La administración de memoria y la computación en paralelo no están bien soportadas por los lenguajes de sistema más populares.
- La aparición de procesadores con varios núcleos generó confusiones, preocupaciones y nuevos problemas.

* Problemas
Google tiene problemas... muy grandes.

Muchas líneas de código (millones, casi todo C++, el resto es Java y Python).

Muchos programadores distribuidos alrededor del mundo cambiando muchas cosas al mismo tiempo.

[[http://google-engtools.blogspot.com.ar/2011/06/build-in-cloud-accessing-source-code.html][Y todo funciona (bien)]]

El proceso de desarrollo es extenso, suele ser lento y casi siempre es desprolijo... pero _es_ efectivo.

* Go
Vale la pena crear un nuevo lenguaje para hacer más eficiente el desarrollo.

Objetivos

- Compilar un programa en una computadora en pocos segundos.
- Modelo de arquitectura que facilite el análisis de dependencias.
- Gestión de memoria (GC).
- Comunicación y ejecución de tareas concurrentes.
- Arquitectura de software orientada a computadoras con varios procesadores.
- Sintaxis simple y regular.
- Librería de utilidades completa (_"Batteries_included"_).

* Historia
Septiembre de 2007, Robert Griesemer (v8), Rob Pike (UTF-8) y Ken Thompson (C) comenzaron a definir los objetivos para un nuevo lenguaje.

Noviembre de 2009, Go se convirtió en un proyecto público y "open source".

Marzo de 2012 se publica Go 1 (Garantía de compatibilidad)

Junio de 2014 se publica Go 1.3

Go 1.4 (diciembre de 2014)

* Influencias
C: sintaxis y expresiones.
Pascal: declaración de variables.
Modula 2, Oberon 2: paquetes para distribución.
CSP, Occam, Newsqueak, Limbo, Alef: concurrencia.
BCPL: reglas de inserción de ";".
Smalltalk: métodos.
Newsqueak: <-, :=
APL: iota

Se agregaron nuevas ideas: defer, constants.

Y lecciones aprendidas de:
C++, C#, Java, JavaScript, LISP, Python, Scala, ...
(_Pero_Go_es_más_interesante_por_lo_que_no_tiene_)

* Código

* Hello Gophers!

.play go101/hello.go

.image go101/img/gophers.jpg 300 _

* Paquetes
Todos los programas en Go están formados paquetes.
Los programas comienzan a ejecutarse en el `package` `main`.

.play go101/packages.go

Este programa importa los paquetes "fmt" y "math/rand".
Por convención el nombre del paquete es la última parte del "path".

* Nombres exportados
Una vez importado un paquete, se puede acceder a los nombres que exporta.

.play go101/exported.go

* Funciones
Sintaxis

.play go101/sum.go /START/,/STOP/

* Funciones
Pueden devolver más de un resultado

.play go101/split.go /START/,/STOP/

Errores en lugar de excepciones

.code go101/split.go /^func.WriteString/,/}/

* Closures

Un "closure" es una función que referencia variables fuera de su cuerpo.

.play go101/closures.go /START/,/STOP/

* Tipos
Determinan un conjunto de valores y operaciones específicos.

Implícitos: int(8, 16, 32, 64), uint, float, complex64, bool, byte, rune, string, error

Compuestos:

.play go101/point.go /START/,/STOP/

* Métodos
Agregan comportamiento a los tipos

.play go101/point-with-method.go /START/,/STOP/

* Otros tipos implícitos

- Array: `var` `a` `[2]string`
- Slice: `var` `a` `[]string` (referencia a un Array, crece como sea necesario usando la función append())
- Map: `var` `a` `map[string]Point`
- Channels: `var` `a` `chan` `int`

Funciones

- `append(a,` `b)`
- `len(a)`
- `new` vs `make`

* Interfaces
Describen comportamiento: si puede hacer _esto_, entonces puede usarse _aquí_

.play go101/stringer.go /START/,/STOP/

* Valores y referencias
Los operadores `&` y `*` sirven para referenciar y desreferenciar valores y direcciones de memoria.
En la mayoría de los casos, Go se encarga de convertir referencias a valores cuando es necesario.

Métodos que aplican sobre referencias:

.code go101/point-with-method.go /REFERENCE/,/STOPREFERENCE/

* Concurrencia

* Concurrencia
Go promueve el desarrollo de software concurrente.

¿Qué es la concurrencia?

¿Por qué incluirla como un aspecto principal del lenguaje?

¿Qué vemos a nuestro alrededor?

¿Nuestra realidad se puede representar de manera secuencial?

¿O es un conjunto de interacciones independientes?

* ¿Qué significa concurrencia?

Es la composición de procesos de computación que se ejecutan de manera independiente.

Concurrencia no es lo mismo que paralelismo (aunque lo facilita).
.link http://golang.org/s/concurrency-is-not-parallelism
Concurrencia: administrar varias tareas al mismo tiempo.
Paralelismo: hacer varias tareas al mismo tiempo.

La concurrencia se ocupa de la estructura, mientras que el paralelismo se encarga de la ejecución.

Es una forma de escribir código que interactúa bien con nuestra realidad.

* Concurrencia en Go

- Fácil de entender
- Fácil de usar
- ¡No hay que ser un experto!

(Mucho más simple que lidiar con  paralelismo (threads, semáforos, locks, barreras, etc...))

* Una función simple

.play go101/fibonacci.1.0.go

* Un poco más impredecible

.play go101/fibonacci.1.1.go /START/,/STOP/

* Basta de esperar
La palabra reservada "go" permite iniciar una "go-rutina", una función que se ejecuta de manera independiente.

.play go101/fibonacci.2.0.go /START/,/STOP/

Las "go-rutinas":
 - NO SON threads (puede haber un único thread con varias "go-rutinas")
 - Tienen su propia "pila" (crece y disminuye según sea necesario)
 - Son simples y eficientes en el manejo de recursos (se pueden tener cientos o miles)

* Esperando de nuevo

.play go101/fibonacci.2.1.go /START/,/STOP/

* Comunicación

* Channels
Proveen un mecanismo de comunicación entre dos funciones que se ejecutan de manera concurrente.
Permite enviar y recibir valores de un tipo determinado.

	chan T          // recibe y envía valores de tipo T
	chan<- float64  // sólo envía float64s
	<-chan int      // sólo recibe ints

* Comunicación

.play go101/fibonacci.3.0.go /START/,/STOP/

* Sincronización
Cuando la función principal ejecuta "<-c" espera hasta que recibe un valor.

De la misma manera, cuando nuestra función ejecuta "c <- value" espera hasta que un receptor esté disponible.

Ambos extremos deben estar listos para participar de la comunicación. Si no, se espera.

Los channels cumplen la función de sincronizar y comunicar.

* Principios
Don't communicate by sharing memory, share memory by communicating.

* Redundancia

.play go101/fibonacci.3.1.go /START/,/STOP/

Problema: Bob bloquea hasta que Alice está lista.

* Fan In

.code go101/fibonacci.3.2.go /STARTFANIN/,/STOPFANIN/

`select` elige qué operación se va a ejecutar dentro de un set de operaciones de entrada/salida.

* Fan In

.play go101/fibonacci.3.2.go /STARTMAIN/,/STOPMAIN/

.image go101/img/gophermegaphones.jpg 350 _

* Timeout y close()

.code go101/fibonacci.3.3.go /STARTFANIN/,/STOPFANIN/

`close()` permite cerrar un channel. Una vez cerrado, devuelve siempre el valor cero del tipo del channel sin bloquear.

* Timeout y close()

.play go101/fibonacci.3.3.go /STARTMAIN/,/STOPMAIN/

* Utilidades y más...
- go build
- go install
- go test
- go doc
- go get
- go fmt
- go vet
- go run

* Links

- Home: [[http://golang.org]]
- A tour of Go: [[http://tour.golang.org]]
- Documentación: [[http://golang.org/pkg]]
- Artículos: [[http://golang.org/doc]]
- Presentaciones: [[http://talks.golang.org]]
- Concurrency is not parallelism: [[http://golang.org/s/concurrency-is-not-parallelism]]
- The laws of reflection: [[http://blog.golang.org/laws-of-reflection]]
- Go Advent Days: [[http://blog.gopheracademy.com/day-24-thank-you]]
- Playground: [[http://play.golang.org]]