-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathpresentacion.slide
398 lines (227 loc) · 10.6 KB
/
presentacion.slide
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
Go: un entorno de programación sencillo
19 Abril 2014
# Go es un lenguaje de propósito general que sirve de puente entre la
# eficiencia de un lenguaje tipado y la productividad de un lenguaje
# dinámico. Pero no es unicamente el lenguaje lo que lo hace especial
# a Go – Go tiene una librería estándar amplia y consistente y
# herramientas poderosas pero sencillas.
#
# Esta charla es una introducción a Go, seguido por un recorrido a
# algunos programas reales para demostrar el poder, alcance y sencillez
# del entorno de desarrollo en Go.
Gabriel Pozo
Programador
http://aprendiendodeandroidymas.com
@jackgris2
http://plus.google.com/+GabrielPozo
* Porque un nuevo lenguaje?
Motivo, la necesidad de Google.
Necesitaba:
- Eficiencia
- Seguridad
- Concurrencia
- Escalabilidad
- Un ciclo de desarrollo rápido
- No tener sorpresas
- Una linda mascota
* Diseño
"El consenso condujo al diseño. Nada salio en el lenguaje hasta que [Ken Thompson, Robert Griesemer, y yo] todos coincidieron en que era lo correcto. Algunas características no se resolvieron hasta un año o mas, después de la discusión." - Rob Pike
Go es:
- Ligero, nos evita repeticiones innecesaria
- Orientado a objetos, pero no de la forma habitual
- Concurrente, de una forma que te mantiene cuerdo
- Diseñado para los programadores que trabajan
* Go 1
Liberado en Marzo del 2012
Especificación del lenguaje y librerías que serán soportadas por años.
Garantía: el código escrito para Go 1.0 podrá ser compilado y ejecutado con Go 1.x.
La mejor cosa que hemos hecho (palabras de los desarrolladores)
* La mascota (The gopher)
.image images/gopher.jpg
* Hello, go
.play code/hello.go
* Librería estándar
* Paquetes
El código de Go se crea en paquetes.
Los paquetes contienen declaraciones de tipos, funciones, variables, y contantes.
Los paquetes pueden ser muy pequeños (paquete `errors` tiene solo una declaración) o muy grandes (paquete `net/http` tiene >100 declaraciones).
Las mayúsculas determinan la accesibilidad: `Foo` es exportada, `foo` no lo es
* io
El paquete `io` nos provee las interfaces fundamentales para el manejo de I/O que se utiliza en la mayoría del código en Go.
Las mas extendidas son los tipos `Reader` y `Writer`, que describen los streams de datos.
.code code/io/io.go
Las implementaciones de `Reader` y `Writer` incluyen archivos(files), sockets, (des)comprimir, imágenes, JSON, y muchos mas.
* Encadenar io.Readers
.play code/reader.go
* net/http
El paquete `net/http` implementa un servidor y cliente HTTP.
.play code/hello-web.go
* encoding/json
El paquete `encoding/json`convierte los datos desde JSON hacia estructuras de datos nativas en Go y viceversa.
.play code/json.go /const/,$
* time
El paquete `time` nos provee una representación del tiempo, duración y otras funciones útiles relacionadas con el tiempo.
.play code/time.go /START/,/END/
.play code/time2.go /START/,/END/
`time.Time` también contiene valores como `time.Location` (solo para mostrar):
.play code/time3.go /START/,/END/
* flag
El paquete `flag` nos provee una API sencilla para analizar opciones de lineas de comando.
.play code/flag.go
$ flag -message 'Hold on...' -delay 5m
* Herramientas
* La herramienta go
La herramienta `go` es la estándar para construir e instalar código Go.
Compilar un simple archivo y ejecutar el programa:
$ go run hello.go
Construir e instalar el paquete del directorio actual y sus dependencias:
$ go install
Construir e instalar el paquete `fmt` y sus dependencias:
$ go install fmt
Esta herramienta actúa como una interfaz para la mayoría de las otras herramientas de Go.
* Importar paths
`go` es una herramienta "sin configuración" ("zero configuration"). No necesita Makefiles o scripts. Solo código Go.
Su esquema de compilación y código están siempre sincronizados; ellos son uno al mismo tiempo.
Las rutas para importar los paquetes reflejan la ruta donde esta ubicado el código en nuestro sistema de ficheros:
src/
github.com/nf/
gosynth/
main.go
note.go
osc.go
wav/
writer.go
El programa `gosynth` importa el paquete `wav`:
import "github.com/nf/wav"
Instalando `gosynth` va a instalar automáticamente el paquete `wav`:
$ go install github.com/nf/gosynth
* Dependencias remotas
La herramienta `go` también puede tomar código Go desde repositorios remotos.
El paths de importación pueden ser URLs:
import "code.google.com/p/go.net/websocket"
Para obtener, compilar e instalar un paquete:
$ go get code.google.com/p/go.net/websocket
Para obtener, compilar e instalar `gosynth` y sus dependencias:
$ go get github.com/nf/gosynth
Este diseño sencillo nos conduce a otras herramientas interesantes:
.link http://go.pkgdoc.org
* Godoc
Godoc extrae la documentación desde el mismo código Go y lo presenta en una variedad de formas.
Los comentarios no necesitan ningún formato en particular, solo tiene que preceder a lo que documentan.
// Split slices s into all substrings separated by sep and returns a slice of
// the substrings between those separators.
// If sep is empty, Split splits after each UTF-8 sequence.
// It is equivalent to SplitN with a count of -1.
func Split(s, sep string) []string {
.image images/split.png
La documentación vive con el código, es sencillo mantenerla actualizada.
* Gofmt
La herramienta `gofmt` nos va a dar un lindo formato para nuestro código fuente.
Todo el código del núcleo de Go fue formateado con gofmt, y aproximadamente el ~70% del código libre también.
Fin de discusiones aburridas sobre el formato.
Mejora la legibilidad. Mejora la capacidad de escritura.
Nos ahorra una gran cantidad de tiempo.
* Tests: escribir
La herramienta `go` en el paquete `testing` nos provee un framework sencillo para escribir test.
.code code/test/string_test.go /func TestIndex/,/^}/
* Tests: correr
La herramienta go corre los tests.
$ go test
PASS
$ go test -v
=== RUN TestIndex
--- PASS: TestIndex (0.00 seconds)
PASS
Para correr los tests de todo el proyecto:
$ go test github.com/nf/...
* Tests: benchmarks
El paquete `testing` también soporta benchmarks.
Una función de ejemplo de benchmark:
.code code/test/string_test.go /func BenchmarkIndex/,/^}/
El paquete benchmark va a varias `b.N` hasta que la función de benchmark dure el tiempo suficiente para ser cronometrado de forma fiable.
$ go test -test.bench=Index
PASS
BenchmarkIndex 50000000 37.3 ns/op
* Tests: ejemplo
El paquete `testing` también soporta ejemplos comprobables.
.code code/test/string_test.go /func ExampleIndex/,/^}/
Ejemplo de como construir y correr como parte de una suite normal de test:
$ go test -v
=== RUN: ExampleIndex
--- PASS: ExampleIndex (0.00 seconds)
PASS
El ejemplo es mostrado en `godoc` para demostrarlo:
.link http://golang.org/pkg/strings/#Index
* Y otros mas
- `vet`: verificación de código para errores comunes de los programadores
- `pprof`: uso de CPU y memoria
- `fix`: migrar código automáticamente como el cambio de APIs
- soporte para GDB
- Soporte para editores: Vim, Emacs, Eclipse, Sublime Text
* Un ejemplo
* Webfront
`Webfront` es un servidor HTTP y proxy inverso.
Lee un archivo de reglas de configuración en formato JSON como este:
.code code/webfront/main.go /^\[/,/\]/
Para todas las peticiones en el host `example.com` (o cualquier nombre que finalice en `".example.com"`) este servirá archivos desde el directorio `/var/www`.
Para solicitudes a `example.org`, reenviara la solicitud al servidor HTTP que escucha en localhost a través del puerto 8080.
* El tipo Rule (regla)
Un valor `Rule` especifica que debe hacer para una solicitud a un host específico.
.code code/webfront/main.go /Rule representa/,/^}/
Se corresponde directamente con las entradas en el archivo de configuración JSON.
.code code/webfront/main.go /^\[/,/\]/
* Métodos de Rule
.code code/webfront/main.go /Match devuelve/,/^}/
.code code/webfront/main.go /Handler devuelve/,/^}/
* El tipo Server
El tipo `Server` es el responsable de cargar y refrescar las reglas desde el archivo y servir las peticiones HTTP con el "manejador" (o handler) apropiado.
.code code/webfront/main.go /Server implementa/,/^}/
.code code/webfront/main.go /ServeHTTP compara/,/^}/
* El método handler
.code code/webfront/main.go /handler devuelve/,/^}/
* Análisis de las reglas (Parsing rules)
La función `parseRules` utiliza el paquete `encoding/json` para leer el archivo de reglas en una estructura de datos de Go.
.code code/webfront/main.go /parseRules lee/,/^}/
* El método loadRules
.code code/webfront/main.go /loadRules comprueba/,/^}/
* Construyendo el servidor
.code code/webfront/main.go /NewServer construye/,/^}/
Este constructor lanza una goroutine para correr el método `refreshRules`.
* Refrescando las reglas
.code code/webfront/main.go /refreshRules lee/,/^}/
* Colocar todo junto
La función main analiza las opciones que se le pasan en la linea de comando, construye un objeto `Server`, y lanza un servidor HTTP que sirve todas las peticiones con `Server`.
.code code/webfront/main.go /^var/,/^}/
* Demo
* Testing (1/3)
El test de integración de `Server` utiliza el paquete `httptest` para construir un servidor HTTP ficticio, sintetiza un conjunto de reglas, y construye una instancia `Server` que utiliza esas reglas.
.code code/webfront/server_test.go /^func testHandler/,/STOP/
* Testing (2/3)
Casos de prueba, en la tabla se específica una URL para cada tipo de solicitud y el cuerpo y código de respuesta esperada.
.code code/webfront/server_test.go /TESTS START/,/STOP/
* Testing (3/3)
Para cada caso de prueba, construye un `http.Request` para la url y un `httptest.ResponseRecorder` para capturar la respuesta, y se los pasa al método `Server.ServeHTTP`. Entonces verifica que la respuesta coincida con el caso de prueba.
.code code/webfront/server_test.go /RANGE START/,/^}/
* Demostración
* Quienes lo usan?
Por parte de Google y terceros (como Mozilla y Canonical)
.link http://dl.google.com
.link https://code.google.com/p/vitess
.link http://www.iron.io
.link http://www.cloudflare.com
.link https://juju.ubuntu.com
.link http://heka-docs.readthedocs.org/en/latest
Otros proyectos
.link https://github.com/bitly/nsq
.link https://github.com/remogatto/mandala
* Conclusiones
Un tweet interesante por parte de Rob Pike
“Just looked at a Google-internal Go server with 139K goroutines serving
over 68K active network connections. Concurrency wins. #golang”
* Mas información
Todo sobre Go:
.link http://golang.org
Presentación de la cual esta basada esta charla:
.link http://talks.golang.org/2012/simple.slide
webfront:
.link https://github.com/nf/webfront