A apresentação introduz a linguagem Go, destacando suas características como tipagem dinâmica em um sistema de tipos estáticos, ausência de herança mas presença de métodos, e dois compiladores principais. Exemplos demonstram sintaxes como declaração de variáveis, estruturas de controle, funções, maps, channels e paralelismo.

1. Lightning talks
Rodrigo Hübner

2. O que têm?
● Nova :)
● Experimental ¬¬
● Concorrente :D
● Coletor de lixo ¬¬
● Programação de Sistemas o/
● Linguagem divertida e moderna

3. Maaais sobre o Compilador
● Impressão de tipagem dinâmica em um sistema
de tipo estático
● Tipos são bem flexíveis
● Existe métodos mas não NÃO é OO
● Compilador 6g (ken)
● Experimental, código ótimo e rápido, não liga GCC
● Compilador gccgo (iant)
● Tradicional, código bom e não tão rápido, liga GCC

4. Olá Mundo
package main
import "fmt"
func main() {
fmt.Print("Hello, Worldn")
}

5. Variáveis e Estruturas de Controle
var a int
var b, c *int // note a diferença com C
var d []int
type S struct { a, b int }
if a == b { return true } else { return false }
for i = 0; i < 10; i++ { ... }

6. Algumas mudanças em relação a C
+x
23 + 3*x[i]
x <= f()
^a >> b
f() || g()
x == y + 1 && <­chan_ptr > 0
x &^ 7 // x com 3 bits baixos em 0
fmt.Printf("%5.2gn", 2*math.Sin(PI/8))
"hello" ", " "there" // concatenação léxica
"hello, " + str // concatenação dinâmica

7. Vamos melhorar
var (
i int;
j = 356.245;
k int = 0;
l, m uint64 = 1, 2;
billion int64 = 1e9;
inter, floater, stringer = 1, 2.0, "hi"
)

8. iota
const (
Monday = iota;
Tuesday = iota;
)

9. If aprimorado
if v := f(); v < 10 {
fmt.Printf("%d less than 10n", v)
} else {
fmt.Printf("%d not less than 10", v)
}
if n, err = fd.Write(buf); err != nil { ... }

10. for aprimorado
for i,j := 0,N; i < j; i,j = i+1,j­1 {...}

11. Switch-case
a, b := x[i], y[j];
switch {
case a < b: return ­1
case a == b: return 0
case a > b: return 1
}
ou
switch a, b := x[i], y[j]; { ... }

12. Break ?
Loop: for i := 0; i < 10; i++ {
switch f(i) {
case 0, 1, 2: break Loop
}
g(i)
}

13. Funções e retornos
func MySqrt(f float) (v float, ok bool) {
if f >= 0 { v,ok = math.Sqrt(f),true }
return v,ok
}
func MySqrt(f float) (v float, ok bool) {
if f >= 0 { v,ok = math.Sqrt(f),true }
return // must be explicit
}
func MySqrt(f float) (v float, ok bool) {
if f < 0 { return } // error case
return math.Sqrt(f),true
}

14. defer
func f() {
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}
}
// prints 4 3 2 1 0

15. Arrays e operações
func fp(a *[3]int) { fmt.Println(a) }
func main() {
for i := 0; i < 3; i++
fp(&[3]int{i, i*i, i*i*i})
}
}
Saída:
&[0 0 0]
&[1 1 1]
&[2 4 8]
var ar = [10]int{0,1,2,3,4,5,6,7,8,9}
var a = &ar[5:7] // referencia → {5,6}

16. Maps
m = map[string]float { "1":1, "pi":3.1415 }
// Acessar um elemento como um valor
one := m["1"]
crash := m["not present"] // error
// Criar novos elementos e atualizá­los
m["2"] = 2;
m["2"] = 3;
// Em laço for
m := map[string]float { "1":1.0, "pi":3.1415 };
for key, value := range m {
fmt.Printf("key %s, value %gn", key, value)
}

17. closures
func adder() (func(int) int) {
var x int;
return func(delta int) int {
x += delta;
return x
}
}
var f = adder();
fmt.Print(f(1));
fmt.Print(f(20));
fmt.Print(f(300));
// Imprime 1 21 321

18. Bibliotecas

19. Paralelismo
var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)
func server() {
for {
b := <-serverChan; // wait for work
process(b);
ok := freeList <- b // reuse buffer if room
}
}
func client() {
for {
b, ok := <-freeList; // grab one if available
if !ok { b = new(Buffer) }
load(b);
serverChan <- b // send to server
}
}

20. Mais
● Métodos em structs
● Interfaces
● Many to many
● Iterators e generators
● http://golang.org/