SlideShare a Scribd company logo
go 
for the would-be network programmer 
@feyeleanor 
go for the would-be network programmer 1 http://slides.games-with-brains.net/
twitter://@feyeleanor 
leanpub://GoNotebook 
go for the would-be network programmer http://slides.games-with-brains.net/
high voltage 
networking 
concurrency 
cryptography 
go for the would-be network programmer http://slides.games-with-brains.net/
http 
go for the would-be network programmer 4 http://slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
"net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
http.HandleFunc("/hello", Hello) 
if e := http.ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w http.ResponseWriter, r *http.Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://5 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
"net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
http.HandleFunc("/hello", Hello) 
if e := http.ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w http.ResponseWriter, r *http.Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://6 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
"net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
http.HandleFunc("/hello", Hello) 
if e := http.ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w http.ResponseWriter, r *http.Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://7 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", Hello) 
if e := ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://8 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. ”net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", Hello) 
if e := ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://9 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. ”net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", Hello) 
if e := ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://10 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. ”net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", Hello) 
if e := ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://11 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. ”net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", Hello) 
if e := ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://12 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. ”net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", Hello) 
if e := ListenAndServe(ADDRESS, nil); e != nil { 
Println(e) 
} 
} 
func Hello(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
} 
go for the would-be network programmer http://13 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
}) 
ListenAndServe(ADDRESS, nil) 
} 
go for the would-be network programmer http://14 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const MESSAGE = "hello world" 
const ADDRESS = ":1024" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, MESSAGE) 
}) 
ListenAndServe(ADDRESS, nil) 
} 
go for the would-be network programmer http://15 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const ADDRESS = ":1025" 
func main() { 
message := "hello world" 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, message) 
}) 
ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) 
} 
go for the would-be network programmer http://16 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const ADDRESS = ":1025" 
func main() { 
message := "hello world" 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, message) 
}) 
ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) 
} 
go for the would-be network programmer http://17 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const ADDRESS = ":1025" 
func main() { 
message := "hello world" 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, message) 
}) 
ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) 
} 
go for the would-be network programmer http://18 slides.games-with-brains.net/
package main 
import ( 
. "fmt" 
. "net/http" 
) 
const ADDRESS = ":1025" 
func main() { 
message := "hello world" 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, message) 
}) 
ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) 
} 
go for the would-be network programmer http://19 slides.games-with-brains.net/
concurrency 
go for the would-be network programmer 20 http://slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://21 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://22 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://23 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://24 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://25 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://26 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://27 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://28 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
done := make(chan bool) 
go func() { 
ListenAndServe(":1024", nil) 
done <- true 
}() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
<- done 
} 
go for the would-be network programmer http://29 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
Spawn( 
func() { 
ListenAndServe(":1024", nil) 
}, 
func() { 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}, 
) 
} 
go for the would-be network programmer http://30 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
Spawn(func() { 
ListenAndServe(":1024", nil) 
}) 
Spawn(func() { 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}) 
} 
go for the would-be network programmer http://31 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://32 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://33 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://34 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://35 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://36 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://37 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
done := make(chan bool) 
for _, s := range f { 
go func(server func()) { 
server() 
done <- true 
}(s) 
} 
for l := len(f); l > 0; l-- { 
<- done 
} 
} 
go for the would-be network programmer http://38 slides.games-with-brains.net/
waitgroups 
go for the would-be network programmer 39 http://slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) 
var servers sync.WaitGroup 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServe(":1024", nil) 
}() 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}() 
servers.Wait() 
} 
go for the would-be network programmer http://40 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) 
var servers sync.WaitGroup 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServe(":1024", nil) 
}() 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}() 
servers.Wait() 
} 
go for the would-be network programmer http://41 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) 
var servers sync.WaitGroup 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServe(":1024", nil) 
}() 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}() 
servers.Wait() 
} 
go for the would-be network programmer http://42 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) 
var servers sync.WaitGroup 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServe(":1024", nil) 
}() 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}() 
servers.Wait() 
} 
go for the would-be network programmer http://43 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) 
var servers sync.WaitGroup 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServe(":1024", nil) 
}() 
servers.Add(1) 
go func() { 
defer servers.Done() 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}() 
servers.Wait() 
} 
go for the would-be network programmer http://44 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
var servers sync.WaitGroup 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
Spawn(func() { 
ListenAndServe(":1024", nil) 
}) 
Spawn(func() { 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}) 
servers.Wait() 
} 
go for the would-be network programmer http://45 slides.games-with-brains.net/
package main 
import . "fmt" 
import . "net/http" 
import "sync" 
var servers sync.WaitGroup 
func main() { 
HandleFunc("/hello", func(w ResponseWriter, r *Request) { 
w.Header().Set("Content-Type", "text/plain") 
Fprintf(w, "hello world") 
}) 
Spawn(func() { 
ListenAndServe(":1024", nil) 
}) 
Spawn(func() { 
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) 
}) 
servers.Wait() 
} 
go for the would-be network programmer http://46 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
for _, s := range f { 
servers.Add(1) 
go func(server func()) { 
defer servers.Done() 
server() 
}(s) 
} 
} 
go for the would-be network programmer http://47 slides.games-with-brains.net/
package main 
func Spawn(f ...func()) { 
for _, s := range f { 
servers.Add(1) 
go func(server func()) { 
defer servers.Done() 
server() 
}(s) 
} 
} 
go for the would-be network programmer http://48 slides.games-with-brains.net/
tcp 
go for the would-be network programmer 49 http://slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
if listener, e := net.Listen("tcp", ":1024"); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://50 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
if listener, e := net.Listen("tcp", ":1024"); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://51 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
if listener, e := net.Listen("tcp", ":1024"); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://52 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
if listener, e := net.Listen("tcp", ":1024"); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://53 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
if listener, e := net.Listen("tcp", ":1024"); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://54 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
Listen("tcp", ":1024", func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}) 
} 
func Listen(p, a string, f func(net.Conn)) (e error) { 
var listener net.Listener 
if listener, e = net.Listen(p, a); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go f(connection) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://55 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
Listen("tcp", ":1024", func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}) 
} 
func Listen(p, a string, f func(net.Conn)) (e error) { 
var listener net.Listener 
if listener, e = net.Listen(p, a); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go f(connection) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://56 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
Listen("tcp", ":1024", func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}) 
} 
func Listen(p, a string, f func(net.Conn)) (e error) { 
var listener net.Listener 
if listener, e = net.Listen(p, a); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go f(connection) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://57 slides.games-with-brains.net/
package main 
import . "fmt" 
import "net" 
func main() { 
Listen("tcp", ":1024", func(c net.Conn) { 
defer c.Close() 
Fprintln(c, "hello world") 
}) 
} 
func Listen(p, a string, f func(net.Conn)) (e error) { 
var listener net.Listener 
if listener, e = net.Listen(p, a); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go f(connection) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://58 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
if c, e := net.Dial("tcp", ":1024"); e == nil { 
defer c.Close() 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
} 
} 
go for the would-be network programmer http://59 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
if c, e := net.Dial("tcp", ":1024"); e == nil { 
defer c.Close() 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
} 
} 
go for the would-be network programmer http://60 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
if c, e := net.Dial("tcp", ":1024"); e == nil { 
defer c.Close() 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
} 
} 
go for the would-be network programmer http://61 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
if c, e := net.Dial("tcp", ":1024"); e == nil { 
defer c.Close() 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
} 
} 
go for the would-be network programmer http://62 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
if c, e := net.Dial("tcp", ":1024"); e == nil { 
defer c.Close() 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
} 
} 
go for the would-be network programmer http://63 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
if c, e := net.Dial("tcp", ":1024"); e == nil { 
defer c.Close() 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
} 
} 
go for the would-be network programmer http://64 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial("tcp", ":1024", func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
go for the would-be network programmer http://65 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial("tcp", ":1024", func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
func Dial(p, a string, f func(net.Conn)) (e error) { 
var c net.Conn 
if c, e = net.Dial(p, a); e == nil { 
defer c.Close() 
f(c) 
} 
return 
} 
go for the would-be network programmer http://66 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial("tcp", ":1024", func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
func Dial(p, a string, f func(net.Conn)) (e error) { 
var c net.Conn 
if c, e = net.Dial(p, a); e == nil { 
defer c.Close() 
f(c) 
} 
return 
} 
go for the would-be network programmer http://67 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial("tcp", ":1024", func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
func Dial(p, a string, f func(net.Conn)) (e error) { 
var c net.Conn 
if c, e = net.Dial(p, a); e == nil { 
defer c.Close() 
f(c) 
} 
return 
} 
go for the would-be network programmer http://68 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial("tcp", ":1024", func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
func Dial(p, a string, f func(net.Conn)) (e error) { 
var c net.Conn 
if c, e = net.Dial(p, a); e == nil { 
defer c.Close() 
f(c) 
} 
return 
} 
go for the would-be network programmer http://69 slides.games-with-brains.net/
tcp/tls 
go for the would-be network programmer 70 http://slides.games-with-brains.net/
package main 
import "crypto/tls" 
import . "fmt" 
func main() { 
Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) { 
Fprintln(c, "hello world") 
}) 
} 
go for the would-be network programmer http://71 slides.games-with-brains.net/
package main 
import "crypto/tls" 
import . "fmt" 
func main() { 
Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) { 
Fprintln(c, "hello world") 
}) 
} 
go for the would-be network programmer http://72 slides.games-with-brains.net/
package main 
import "crypto/tls" 
import . "fmt" 
func main() { 
Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) { 
Fprintln(c, "hello world") 
}) 
} 
go for the would-be network programmer http://73 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
Rand: rand.Reader, 
} 
} 
return 
} 
go for the would-be network programmer http://74 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
Rand: rand.Reader, 
} 
} 
return 
} 
go for the would-be network programmer http://75 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
Rand: rand.Reader, 
} 
} 
return 
} 
go for the would-be network programmer http://76 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
Rand: rand.Reader, 
} 
} 
return 
} 
go for the would-be network programmer http://77 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
Rand: rand.Reader, 
} 
} 
return 
} 
go for the would-be network programmer http://78 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { 
if listener, e := tls.Listen("tcp", a, conf); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c *tls.Conn) { 
defer c.Close() 
f(c) 
}(connection.(*tls.Conn)) 
} 
} 
} 
} 
go for the would-be network programmer http://79 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { 
if listener, e := tls.Listen("tcp", a, conf); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c *tls.Conn) { 
defer c.Close() 
f(c) 
}(connection.(*tls.Conn)) 
} 
} 
} 
} 
go for the would-be network programmer http://80 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { 
if listener, e := tls.Listen("tcp", a, conf); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c *tls.Conn) { 
defer c.Close() 
f(c) 
}(connection.(*tls.Conn)) 
} 
} 
} 
} 
go for the would-be network programmer http://81 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { 
if listener, e := tls.Listen("tcp", a, conf); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c *tls.Conn) { 
defer c.Close() 
f(c) 
}(connection.(*tls.Conn)) 
} 
} 
} 
} 
go for the would-be network programmer http://82 slides.games-with-brains.net/
package main 
import “crypto/tls" 
import "net" 
func Listen(a string, conf *tls.Config, f func(net.Conn)) { 
if listener, e := tls.Listen("tcp", a, conf); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
f(c) 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://83 slides.games-with-brains.net/
package main 
import "crypto/tls" 
import "net" 
func Listen(a string, conf *tls.Config, f func(net.Conn)) { 
if listener, e := tls.Listen("tcp", a, conf); e == nil { 
for { 
if connection, e := listener.Accept(); e == nil { 
go func(c net.Conn) { 
defer c.Close() 
f(c) 
}(connection) 
} 
} 
} 
} 
go for the would-be network programmer http://84 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
go for the would-be network programmer http://85 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
go for the would-be network programmer http://86 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) { 
if m, e := bufio.NewReader(c).ReadString('n'); e == nil { 
Printf(m) 
} 
}) 
} 
go for the would-be network programmer http://87 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
InsecureSkipVerify: true, 
} 
} 
return 
} 
go for the would-be network programmer http://88 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
InsecureSkipVerify: true, 
} 
} 
return 
} 
go for the would-be network programmer http://89 slides.games-with-brains.net/
package main 
import "crypto/tls" 
func ConfigTLS(c, k string) (r *tls.Config) { 
if cert, e := tls.LoadX509KeyPair(c, k); e == nil { 
r = &tls.Config{ 
Certificates: []tls.Certificate{ cert }, 
InsecureSkipVerify: true, 
} 
} 
return 
} 
go for the would-be network programmer http://90 slides.games-with-brains.net/
package main 
import “crypto/tls" 
import "net" 
func Dial(a string, conf *tls.Config, f func(net.Conn)) { 
if c, e := tls.Dial("tcp", a, conf); e == nil { 
defer c.Close() 
f(c) 
} 
} 
go for the would-be network programmer http://91 slides.games-with-brains.net/
package main 
import “crypto/tls" 
import "net" 
func Dial(a string, conf *tls.Config, f func(net.Conn)) { 
if c, e := tls.Dial("tcp", a, conf); e == nil { 
defer c.Close() 
f(c) 
} 
} 
go for the would-be network programmer http://92 slides.games-with-brains.net/
udp 
go for the would-be network programmer 93 http://slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://94 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn”) 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://95 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://96 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://97 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://98 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://99 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://100 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://101 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://102 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://103 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://104 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://105 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://106 slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://107 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://108 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://109 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://110 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://111 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://112 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://113 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://114 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://115 slides.games-with-brains.net/
package main 
import "bufio" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1024", func(conn net.Conn) { 
if _, e := conn.Write([]byte("n")); e == nil { 
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { 
Printf("%v", m) 
} 
} 
}) 
} 
func Dial(a string, f func(net.Conn)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
f(conn) 
} 
} 
} 
go for the would-be network programmer http://116 slides.games-with-brains.net/
rsa 
go for the would-be network programmer 117 http://slides.games-with-brains.net/
package main 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello Worldn") 
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
c.WriteToUDP(HELLO_WORLD, a) 
}) 
} 
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.ListenUDP("udp", address); e == nil { 
for b := make([]byte, 1024); ; b = make([]byte, 1024) { 
if n, client, e := conn.ReadFromUDP(b); e == nil { 
go f(conn, client, b[:n]) 
} 
} 
} 
} 
return 
} 
go for the would-be network programmer http://118 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://119 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://120 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://121 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://122 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://123 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://124 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://125 slides.games-with-brains.net/
package main 
import . "bytes" 
import "crypto/rsa" 
import "encoding/gob" 
import "net" 
func main() { 
HELLO_WORLD := []byte("Hello World") 
RSA_LABEL := []byte("served") 
Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { 
var key rsa.PublicKey 
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { 
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { 
c.WriteToUDP(m, a) 
} 
} 
return 
}) 
} 
go for the would-be network programmer http://126 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/rsa" 
import "crypto/sha1" 
func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { 
return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) 
} 
go for the would-be network programmer http://127 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/rsa" 
import "crypto/sha1" 
func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { 
return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) 
} 
go for the would-be network programmer http://128 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/rsa" 
import "crypto/sha1" 
func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { 
return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) 
} 
go for the would-be network programmer http://129 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/rsa" 
import "crypto/sha1" 
func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { 
return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) 
} 
go for the would-be network programmer http://130 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/rsa" 
import "crypto/sha1" 
func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { 
return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) 
} 
go for the would-be network programmer http://131 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { 
if m, e := ReadStream(c); e == nil { 
if m, e := Decrypt(k, m, []byte("served")); e == nil { 
Println(string(m)) 
} 
} 
}) 
} 
go for the would-be network programmer http://132 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { 
if m, e := ReadStream(c); e == nil { 
if m, e := Decrypt(k, m, []byte("served")); e == nil { 
Println(string(m)) 
} 
} 
}) 
} 
go for the would-be network programmer http://133 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { 
if m, e := ReadStream(c); e == nil { 
if m, e := Decrypt(k, m, []byte("served")); e == nil { 
Println(string(m)) 
} 
} 
}) 
} 
go for the would-be network programmer http://134 slides.games-with-brains.net/
package main 
import "crypto/rand" 
import "crypto/rsa" 
import "crypto/sha1" 
func Decrypt(key *rsa.PrivateKey, m, l []byte) ([]byte, error) { 
return rsa.DecryptOAEP(sha1.New(), rand.Reader, key, m, l) 
} 
go for the would-be network programmer http://135 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { 
if m, e := ReadStream(c); e == nil { 
if m, e := Decrypt(k, m, []byte("served")); e == nil { 
Println(string(m)) 
} 
} 
}) 
} 
go for the would-be network programmer http://136 slides.games-with-brains.net/
package main 
import "net" 
func ReadStream(conn *net.UDPConn) (r []byte, e error) { 
m := make([]byte, 1024) 
var n int 
if n, e = conn.Read(m); e == nil { 
r = m[:n] 
} 
return 
} 
go for the would-be network programmer http://137 slides.games-with-brains.net/
package main 
import "net" 
func ReadStream(conn *net.UDPConn) (r []byte, e error) { 
m := make([]byte, 1024) 
var n int 
if n, e = conn.Read(m); e == nil { 
r = m[:n] 
} 
return 
} 
go for the would-be network programmer http://138 slides.games-with-brains.net/
package main 
import "net" 
func ReadStream(conn *net.UDPConn) (r []byte, e error) { 
m := make([]byte, 1024) 
var n int 
if n, e = conn.Read(m); e == nil { 
r = m[:n] 
} 
return 
} 
go for the would-be network programmer http://139 slides.games-with-brains.net/
package main 
import "net" 
func ReadStream(conn *net.UDPConn) (r []byte, e error) { 
m := make([]byte, 1024) 
var n int 
if n, e = conn.Read(m); e == nil { 
r = m[:n] 
} 
return 
} 
go for the would-be network programmer http://140 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func main() { 
Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { 
if m, e := ReadStream(c); e == nil { 
if m, e := Decrypt(k, m, []byte("served")); e == nil { 
Println(string(m)) 
} 
} 
}) 
} 
go for the would-be network programmer http://141 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://142 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://143 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://144 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import "crypto/x509" 
import "encoding/pem" 
import "io/ioutil" 
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { 
if file, e := ioutil.ReadFile(file); e == nil { 
if block, _ := pem.Decode(file); block != nil { 
if block.Type == "RSA PRIVATE KEY" { 
r, e = x509.ParsePKCS1PrivateKey(block.Bytes) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://145 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import "crypto/x509" 
import "encoding/pem" 
import "io/ioutil" 
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { 
if file, e := ioutil.ReadFile(file); e == nil { 
if block, _ := pem.Decode(file); block != nil { 
if block.Type == "RSA PRIVATE KEY" { 
r, e = x509.ParsePKCS1PrivateKey(block.Bytes) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://146 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import "crypto/x509" 
import "encoding/pem" 
import "io/ioutil" 
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { 
if file, e := ioutil.ReadFile(file); e == nil { 
if block, _ := pem.Decode(file); block != nil { 
if block.Type == "RSA PRIVATE KEY" { 
r, e = x509.ParsePKCS1PrivateKey(block.Bytes) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://147 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import "crypto/x509" 
import "encoding/pem" 
import "io/ioutil" 
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { 
if file, e := ioutil.ReadFile(file); e == nil { 
if block, _ := pem.Decode(file); block != nil { 
if block.Type == "RSA PRIVATE KEY" { 
r, e = x509.ParsePKCS1PrivateKey(block.Bytes) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://148 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import "crypto/x509" 
import "encoding/pem" 
import "io/ioutil" 
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { 
if file, e := ioutil.ReadFile(file); e == nil { 
if block, _ := pem.Decode(file); block != nil { 
if block.Type == "RSA PRIVATE KEY" { 
r, e = x509.ParsePKCS1PrivateKey(block.Bytes) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://149 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import "crypto/x509" 
import "encoding/pem" 
import "io/ioutil" 
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { 
if file, e := ioutil.ReadFile(file); e == nil { 
if block, _ := pem.Decode(file); block != nil { 
if block.Type == "RSA PRIVATE KEY" { 
r, e = x509.ParsePKCS1PrivateKey(block.Bytes) 
} 
} 
} 
return 
} 
go for the would-be network programmer http://150 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://151 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://152 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://153 slides.games-with-brains.net/
package main 
import "bytes" 
import “crypto/rsa" 
import "encoding/gob" 
import "net" 
func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) { 
var b bytes.Buffer 
if e := gob.NewEncoder(&b).Encode(k); e == nil { 
if _, e = c.Write(b.Bytes()); e == nil { 
f() 
} 
} 
} 
go for the would-be network programmer http://154 slides.games-with-brains.net/
package main 
import "bytes" 
import “crypto/rsa" 
import "encoding/gob" 
import "net" 
func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) { 
var b bytes.Buffer 
if e := gob.NewEncoder(&b).Encode(k); e == nil { 
if _, e = c.Write(b.Bytes()); e == nil { 
f() 
} 
} 
} 
go for the would-be network programmer http://155 slides.games-with-brains.net/
package main 
import "bytes" 
import “crypto/rsa" 
import "encoding/gob" 
import "net" 
func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) { 
var b bytes.Buffer 
if e := gob.NewEncoder(&b).Encode(k); e == nil { 
if _, e = c.Write(b.Bytes()); e == nil { 
f() 
} 
} 
} 
go for the would-be network programmer http://156 slides.games-with-brains.net/
package main 
import "crypto/rsa" 
import . "fmt" 
import "net" 
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { 
if k, e := LoadPrivateKey(file); e == nil { 
if address, e := net.ResolveUDPAddr("udp", a); e == nil { 
if conn, e := net.DialUDP("udp", nil, address); e == nil { 
defer conn.Close() 
SendKey(conn, k.PublicKey, func() { 
f(conn, k) 
}) 
} 
} 
} 
} 
go for the would-be network programmer http://157 slides.games-with-brains.net/
http://golang.org/ 
go for the would-be network programmer http://158 slides.games-with-brains.net/
twitter://#golang 
go for the would-be network programmer http://159 slides.games-with-brains.net/

More Related Content

What's hot (20)

PDF
goatwork2014
Bryan Liles
 
PDF
How to Avoid Common Mistakes When Using Reactor Netty
VMware Tanzu
 
PDF
FPBrno 2018-05-22: Benchmarking in elixir
Functional Programming Brno
 
PDF
ikh331-06-distributed-programming
Anung Ariwibowo
 
PPTX
QA Fest 2019. Saar Rachamim. Developing Tools, While Testing
QAFest
 
ODP
Pycon Sec
guesta762e4
 
PDF
Decorators demystified
Pablo Enfedaque
 
PDF
Do you Promise?
jungkees
 
PDF
Py conkr 20150829_docker-python
Eric Ahn
 
PDF
Http capturing
Eric Ahn
 
PDF
Alta performance com Python
Bruno Barbosa
 
PDF
The Ring programming language version 1.10 book - Part 92 of 212
Mahmoud Samir Fayed
 
PPTX
Penetration testing using python
Purna Chander K
 
PDF
Going Loopy - Adventures in Iteration with Google Go
Eleanor McHugh
 
PDF
The Ring programming language version 1.6 book - Part 48 of 189
Mahmoud Samir Fayed
 
PPTX
Pulsar Architectural Patterns for CI/CD Automation and Self-Service
Devin Bost
 
PDF
Using New Web APIs For Your Own Pleasure – How I Wrote New Features For My Vi...
GeilDanke
 
PPTX
Introducing to Asynchronous Programming
Александр Федоров
 
goatwork2014
Bryan Liles
 
How to Avoid Common Mistakes When Using Reactor Netty
VMware Tanzu
 
FPBrno 2018-05-22: Benchmarking in elixir
Functional Programming Brno
 
ikh331-06-distributed-programming
Anung Ariwibowo
 
QA Fest 2019. Saar Rachamim. Developing Tools, While Testing
QAFest
 
Pycon Sec
guesta762e4
 
Decorators demystified
Pablo Enfedaque
 
Do you Promise?
jungkees
 
Py conkr 20150829_docker-python
Eric Ahn
 
Http capturing
Eric Ahn
 
Alta performance com Python
Bruno Barbosa
 
The Ring programming language version 1.10 book - Part 92 of 212
Mahmoud Samir Fayed
 
Penetration testing using python
Purna Chander K
 
Going Loopy - Adventures in Iteration with Google Go
Eleanor McHugh
 
The Ring programming language version 1.6 book - Part 48 of 189
Mahmoud Samir Fayed
 
Pulsar Architectural Patterns for CI/CD Automation and Self-Service
Devin Bost
 
Using New Web APIs For Your Own Pleasure – How I Wrote New Features For My Vi...
GeilDanke
 
Introducing to Asynchronous Programming
Александр Федоров
 

Similar to Go for the would be network programmer (20)

PDF
Go for the paranoid network programmer, 3rd edition
Eleanor McHugh
 
PDF
Using Flow-based programming to write tools and workflows for Scientific Comp...
Samuel Lampa
 
PPTX
Net/http and the http.handler interface
Joakim Gustin
 
PPTX
Net/http and the http.handler interface
Evolve
 
PDF
Go Concurrency
jgrahamc
 
PDF
Java Network Programming Fourth Edition Elliotte Rusty Harold
nakorocorway
 
PDF
RESTful Web Applications with Google Go
Frank Müller
 
PDF
Network server in go #gocon 2013-11-14
Jxck Jxck
 
PDF
DevOpsCon 2021: Go Web Development 101
Jan Stamer
 
PDF
entwickler.de Go Day: Go Web Development 101
Jan Stamer
 
PDF
Java Network Programming Third Edition 3rd Edition Elliotte Rusty Harold
dxvpbvqlbt970
 
PDF
Java Network Programming Fourth Edition Harold Elliotte
zubinrlondoit
 
PDF
InterConnect: Server Side Swift for Java Developers
Chris Bailey
 
PDF
Import golang; struct microservice
Giulio De Donato
 
PDF
swift-nio のアーキテクチャーと RxHttpClient
Shinya Mochida
 
PDF
Protocol-Oriented Networking
Mostafa Amer
 
PDF
Go Containers
Cloudflare
 
PDF
Go Containers
jgrahamc
 
KEY
Beauty and Power of Go
Frank Müller
 
PDF
Go Concurrency
Cloudflare
 
Go for the paranoid network programmer, 3rd edition
Eleanor McHugh
 
Using Flow-based programming to write tools and workflows for Scientific Comp...
Samuel Lampa
 
Net/http and the http.handler interface
Joakim Gustin
 
Net/http and the http.handler interface
Evolve
 
Go Concurrency
jgrahamc
 
Java Network Programming Fourth Edition Elliotte Rusty Harold
nakorocorway
 
RESTful Web Applications with Google Go
Frank Müller
 
Network server in go #gocon 2013-11-14
Jxck Jxck
 
DevOpsCon 2021: Go Web Development 101
Jan Stamer
 
entwickler.de Go Day: Go Web Development 101
Jan Stamer
 
Java Network Programming Third Edition 3rd Edition Elliotte Rusty Harold
dxvpbvqlbt970
 
Java Network Programming Fourth Edition Harold Elliotte
zubinrlondoit
 
InterConnect: Server Side Swift for Java Developers
Chris Bailey
 
Import golang; struct microservice
Giulio De Donato
 
swift-nio のアーキテクチャーと RxHttpClient
Shinya Mochida
 
Protocol-Oriented Networking
Mostafa Amer
 
Go Containers
Cloudflare
 
Go Containers
jgrahamc
 
Beauty and Power of Go
Frank Müller
 
Go Concurrency
Cloudflare
 
Ad

More from Eleanor McHugh (20)

PDF
Y - Recursion The Hard Way GopherCon EU 2025
Eleanor McHugh
 
PDF
Never Say, Never Say Die! - the art of low-level Ruby and other Macabre Tales
Eleanor McHugh
 
PDF
[2024] An Introduction to Functional Programming with Go [Y Combinator Remix]...
Eleanor McHugh
 
PDF
[2023] Putting the R! in R&D.pdf
Eleanor McHugh
 
PDF
Generics, Reflection, and Efficient Collections
Eleanor McHugh
 
PDF
The Relevance of Liveness - Biometrics and Data Integrity
Eleanor McHugh
 
PDF
The Browser Environment - A Systems Programmer's Perspective [sinatra edition]
Eleanor McHugh
 
PDF
The Browser Environment - A Systems Programmer's Perspective
Eleanor McHugh
 
PDF
An introduction to functional programming with Go [redux]
Eleanor McHugh
 
PDF
An introduction to functional programming with go
Eleanor McHugh
 
PDF
Implementing virtual machines in go & c 2018 redux
Eleanor McHugh
 
PDF
Identity & trust in Monitored Spaces
Eleanor McHugh
 
PDF
Don't Ask, Don't Tell - The Virtues of Privacy By Design
Eleanor McHugh
 
PDF
Don't ask, don't tell the virtues of privacy by design
Eleanor McHugh
 
PDF
Anonymity, identity, trust
Eleanor McHugh
 
PDF
Distributed Ledgers: Anonymity & Immutability at Scale
Eleanor McHugh
 
PDF
Hello Go
Eleanor McHugh
 
PDF
Finding a useful outlet for my many Adventures in go
Eleanor McHugh
 
PDF
Anonymity, trust, accountability
Eleanor McHugh
 
PDF
Implementing Virtual Machines in Go & C
Eleanor McHugh
 
Y - Recursion The Hard Way GopherCon EU 2025
Eleanor McHugh
 
Never Say, Never Say Die! - the art of low-level Ruby and other Macabre Tales
Eleanor McHugh
 
[2024] An Introduction to Functional Programming with Go [Y Combinator Remix]...
Eleanor McHugh
 
[2023] Putting the R! in R&D.pdf
Eleanor McHugh
 
Generics, Reflection, and Efficient Collections
Eleanor McHugh
 
The Relevance of Liveness - Biometrics and Data Integrity
Eleanor McHugh
 
The Browser Environment - A Systems Programmer's Perspective [sinatra edition]
Eleanor McHugh
 
The Browser Environment - A Systems Programmer's Perspective
Eleanor McHugh
 
An introduction to functional programming with Go [redux]
Eleanor McHugh
 
An introduction to functional programming with go
Eleanor McHugh
 
Implementing virtual machines in go & c 2018 redux
Eleanor McHugh
 
Identity & trust in Monitored Spaces
Eleanor McHugh
 
Don't Ask, Don't Tell - The Virtues of Privacy By Design
Eleanor McHugh
 
Don't ask, don't tell the virtues of privacy by design
Eleanor McHugh
 
Anonymity, identity, trust
Eleanor McHugh
 
Distributed Ledgers: Anonymity & Immutability at Scale
Eleanor McHugh
 
Hello Go
Eleanor McHugh
 
Finding a useful outlet for my many Adventures in go
Eleanor McHugh
 
Anonymity, trust, accountability
Eleanor McHugh
 
Implementing Virtual Machines in Go & C
Eleanor McHugh
 
Ad

Recently uploaded (20)

PPTX
Orchestrating things in Angular application
Peter Abraham
 
PPTX
法国巴黎第二大学本科毕业证{Paris 2学费发票Paris 2成绩单}办理方法
Taqyea
 
PDF
BRKACI-1001 - Your First 7 Days of ACI.pdf
fcesargonca
 
PDF
BRKAPP-1102 - Proactive Network and Application Monitoring.pdf
fcesargonca
 
PDF
Digital burnout toolkit for youth workers and teachers
asociatiastart123
 
PPTX
L1A Season 1 ENGLISH made by A hegy fixed
toszolder91
 
PPTX
Softuni - Psychology of entrepreneurship
Kalin Karakehayov
 
PDF
BRKSP-2551 - Introduction to Segment Routing.pdf
fcesargonca
 
PPTX
西班牙巴利阿里群岛大学电子版毕业证{UIBLetterUIB文凭证书}文凭复刻
Taqyea
 
PDF
Cleaning up your RPKI invalids, presented at PacNOG 35
APNIC
 
PPTX
Metaphysics_Presentation_With_Visuals.pptx
erikjohnsales1
 
PDF
Enhancing Parental Roles in Protecting Children from Online Sexual Exploitati...
ICT Frame Magazine Pvt. Ltd.
 
PPTX
Lec15_Mutability Immutability-converted.pptx
khanjahanzaib1
 
PDF
Boardroom AI: The Next 10 Moves | Cerebraix Talent Tech
ssuser73bdb11
 
PDF
FutureCon Seattle 2025 Presentation Slides - You Had One Job
Suzanne Aldrich
 
PPTX
Presentation3gsgsgsgsdfgadgsfgfgsfgagsfgsfgzfdgsdgs.pptx
SUB03
 
PPTX
Networking_Essentials_version_3.0_-_Module_3.pptx
ryan622010
 
PDF
Top 10 Testing Procedures to Ensure Your Magento to Shopify Migration Success...
CartCoders
 
PPTX
04 Output 1 Instruments & Tools (3).pptx
GEDYIONGebre
 
PDF
BRKACI-1003 ACI Brownfield Migration - Real World Experiences and Best Practi...
fcesargonca
 
Orchestrating things in Angular application
Peter Abraham
 
法国巴黎第二大学本科毕业证{Paris 2学费发票Paris 2成绩单}办理方法
Taqyea
 
BRKACI-1001 - Your First 7 Days of ACI.pdf
fcesargonca
 
BRKAPP-1102 - Proactive Network and Application Monitoring.pdf
fcesargonca
 
Digital burnout toolkit for youth workers and teachers
asociatiastart123
 
L1A Season 1 ENGLISH made by A hegy fixed
toszolder91
 
Softuni - Psychology of entrepreneurship
Kalin Karakehayov
 
BRKSP-2551 - Introduction to Segment Routing.pdf
fcesargonca
 
西班牙巴利阿里群岛大学电子版毕业证{UIBLetterUIB文凭证书}文凭复刻
Taqyea
 
Cleaning up your RPKI invalids, presented at PacNOG 35
APNIC
 
Metaphysics_Presentation_With_Visuals.pptx
erikjohnsales1
 
Enhancing Parental Roles in Protecting Children from Online Sexual Exploitati...
ICT Frame Magazine Pvt. Ltd.
 
Lec15_Mutability Immutability-converted.pptx
khanjahanzaib1
 
Boardroom AI: The Next 10 Moves | Cerebraix Talent Tech
ssuser73bdb11
 
FutureCon Seattle 2025 Presentation Slides - You Had One Job
Suzanne Aldrich
 
Presentation3gsgsgsgsdfgadgsfgfgsfgagsfgsfgzfdgsdgs.pptx
SUB03
 
Networking_Essentials_version_3.0_-_Module_3.pptx
ryan622010
 
Top 10 Testing Procedures to Ensure Your Magento to Shopify Migration Success...
CartCoders
 
04 Output 1 Instruments & Tools (3).pptx
GEDYIONGebre
 
BRKACI-1003 ACI Brownfield Migration - Real World Experiences and Best Practi...
fcesargonca
 

Go for the would be network programmer

  • 1. go for the would-be network programmer @feyeleanor go for the would-be network programmer 1 http://slides.games-with-brains.net/
  • 2. twitter://@feyeleanor leanpub://GoNotebook go for the would-be network programmer http://slides.games-with-brains.net/
  • 3. high voltage networking concurrency cryptography go for the would-be network programmer http://slides.games-with-brains.net/
  • 4. http go for the would-be network programmer 4 http://slides.games-with-brains.net/
  • 5. package main import ( . "fmt" "net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { http.HandleFunc("/hello", Hello) if e := http.ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://5 slides.games-with-brains.net/
  • 6. package main import ( . "fmt" "net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { http.HandleFunc("/hello", Hello) if e := http.ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://6 slides.games-with-brains.net/
  • 7. package main import ( . "fmt" "net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { http.HandleFunc("/hello", Hello) if e := http.ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://7 slides.games-with-brains.net/
  • 8. package main import ( . "fmt" . "net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", Hello) if e := ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://8 slides.games-with-brains.net/
  • 9. package main import ( . "fmt" . ”net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", Hello) if e := ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://9 slides.games-with-brains.net/
  • 10. package main import ( . "fmt" . ”net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", Hello) if e := ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://10 slides.games-with-brains.net/
  • 11. package main import ( . "fmt" . ”net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", Hello) if e := ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://11 slides.games-with-brains.net/
  • 12. package main import ( . "fmt" . ”net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", Hello) if e := ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://12 slides.games-with-brains.net/
  • 13. package main import ( . "fmt" . ”net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", Hello) if e := ListenAndServe(ADDRESS, nil); e != nil { Println(e) } } func Hello(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) } go for the would-be network programmer http://13 slides.games-with-brains.net/
  • 14. package main import ( . "fmt" . "net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) }) ListenAndServe(ADDRESS, nil) } go for the would-be network programmer http://14 slides.games-with-brains.net/
  • 15. package main import ( . "fmt" . "net/http" ) const MESSAGE = "hello world" const ADDRESS = ":1024" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, MESSAGE) }) ListenAndServe(ADDRESS, nil) } go for the would-be network programmer http://15 slides.games-with-brains.net/
  • 16. package main import ( . "fmt" . "net/http" ) const ADDRESS = ":1025" func main() { message := "hello world" HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, message) }) ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) } go for the would-be network programmer http://16 slides.games-with-brains.net/
  • 17. package main import ( . "fmt" . "net/http" ) const ADDRESS = ":1025" func main() { message := "hello world" HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, message) }) ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) } go for the would-be network programmer http://17 slides.games-with-brains.net/
  • 18. package main import ( . "fmt" . "net/http" ) const ADDRESS = ":1025" func main() { message := "hello world" HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, message) }) ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) } go for the would-be network programmer http://18 slides.games-with-brains.net/
  • 19. package main import ( . "fmt" . "net/http" ) const ADDRESS = ":1025" func main() { message := "hello world" HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, message) }) ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil) } go for the would-be network programmer http://19 slides.games-with-brains.net/
  • 20. concurrency go for the would-be network programmer 20 http://slides.games-with-brains.net/
  • 21. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://21 slides.games-with-brains.net/
  • 22. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://22 slides.games-with-brains.net/
  • 23. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://23 slides.games-with-brains.net/
  • 24. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://24 slides.games-with-brains.net/
  • 25. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://25 slides.games-with-brains.net/
  • 26. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://26 slides.games-with-brains.net/
  • 27. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://27 slides.games-with-brains.net/
  • 28. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://28 slides.games-with-brains.net/
  • 29. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) done := make(chan bool) go func() { ListenAndServe(":1024", nil) done <- true }() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) <- done } go for the would-be network programmer http://29 slides.games-with-brains.net/
  • 30. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) Spawn( func() { ListenAndServe(":1024", nil) }, func() { ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }, ) } go for the would-be network programmer http://30 slides.games-with-brains.net/
  • 31. package main import . "fmt" import . "net/http" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) Spawn(func() { ListenAndServe(":1024", nil) }) Spawn(func() { ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }) } go for the would-be network programmer http://31 slides.games-with-brains.net/
  • 32. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://32 slides.games-with-brains.net/
  • 33. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://33 slides.games-with-brains.net/
  • 34. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://34 slides.games-with-brains.net/
  • 35. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://35 slides.games-with-brains.net/
  • 36. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://36 slides.games-with-brains.net/
  • 37. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://37 slides.games-with-brains.net/
  • 38. package main func Spawn(f ...func()) { done := make(chan bool) for _, s := range f { go func(server func()) { server() done <- true }(s) } for l := len(f); l > 0; l-- { <- done } } go for the would-be network programmer http://38 slides.games-with-brains.net/
  • 39. waitgroups go for the would-be network programmer 39 http://slides.games-with-brains.net/
  • 40. package main import . "fmt" import . "net/http" import "sync" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) var servers sync.WaitGroup servers.Add(1) go func() { defer servers.Done() ListenAndServe(":1024", nil) }() servers.Add(1) go func() { defer servers.Done() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }() servers.Wait() } go for the would-be network programmer http://40 slides.games-with-brains.net/
  • 41. package main import . "fmt" import . "net/http" import "sync" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) var servers sync.WaitGroup servers.Add(1) go func() { defer servers.Done() ListenAndServe(":1024", nil) }() servers.Add(1) go func() { defer servers.Done() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }() servers.Wait() } go for the would-be network programmer http://41 slides.games-with-brains.net/
  • 42. package main import . "fmt" import . "net/http" import "sync" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) var servers sync.WaitGroup servers.Add(1) go func() { defer servers.Done() ListenAndServe(":1024", nil) }() servers.Add(1) go func() { defer servers.Done() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }() servers.Wait() } go for the would-be network programmer http://42 slides.games-with-brains.net/
  • 43. package main import . "fmt" import . "net/http" import "sync" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) var servers sync.WaitGroup servers.Add(1) go func() { defer servers.Done() ListenAndServe(":1024", nil) }() servers.Add(1) go func() { defer servers.Done() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }() servers.Wait() } go for the would-be network programmer http://43 slides.games-with-brains.net/
  • 44. package main import . "fmt" import . "net/http" import "sync" func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) {}) var servers sync.WaitGroup servers.Add(1) go func() { defer servers.Done() ListenAndServe(":1024", nil) }() servers.Add(1) go func() { defer servers.Done() ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }() servers.Wait() } go for the would-be network programmer http://44 slides.games-with-brains.net/
  • 45. package main import . "fmt" import . "net/http" import "sync" var servers sync.WaitGroup func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) Spawn(func() { ListenAndServe(":1024", nil) }) Spawn(func() { ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }) servers.Wait() } go for the would-be network programmer http://45 slides.games-with-brains.net/
  • 46. package main import . "fmt" import . "net/http" import "sync" var servers sync.WaitGroup func main() { HandleFunc("/hello", func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") Fprintf(w, "hello world") }) Spawn(func() { ListenAndServe(":1024", nil) }) Spawn(func() { ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil) }) servers.Wait() } go for the would-be network programmer http://46 slides.games-with-brains.net/
  • 47. package main func Spawn(f ...func()) { for _, s := range f { servers.Add(1) go func(server func()) { defer servers.Done() server() }(s) } } go for the would-be network programmer http://47 slides.games-with-brains.net/
  • 48. package main func Spawn(f ...func()) { for _, s := range f { servers.Add(1) go func(server func()) { defer servers.Done() server() }(s) } } go for the would-be network programmer http://48 slides.games-with-brains.net/
  • 49. tcp go for the would-be network programmer 49 http://slides.games-with-brains.net/
  • 50. package main import . "fmt" import "net" func main() { if listener, e := net.Listen("tcp", ":1024"); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }(connection) } } } } go for the would-be network programmer http://50 slides.games-with-brains.net/
  • 51. package main import . "fmt" import "net" func main() { if listener, e := net.Listen("tcp", ":1024"); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }(connection) } } } } go for the would-be network programmer http://51 slides.games-with-brains.net/
  • 52. package main import . "fmt" import "net" func main() { if listener, e := net.Listen("tcp", ":1024"); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }(connection) } } } } go for the would-be network programmer http://52 slides.games-with-brains.net/
  • 53. package main import . "fmt" import "net" func main() { if listener, e := net.Listen("tcp", ":1024"); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }(connection) } } } } go for the would-be network programmer http://53 slides.games-with-brains.net/
  • 54. package main import . "fmt" import "net" func main() { if listener, e := net.Listen("tcp", ":1024"); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }(connection) } } } } go for the would-be network programmer http://54 slides.games-with-brains.net/
  • 55. package main import . "fmt" import "net" func main() { Listen("tcp", ":1024", func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }) } func Listen(p, a string, f func(net.Conn)) (e error) { var listener net.Listener if listener, e = net.Listen(p, a); e == nil { for { if connection, e := listener.Accept(); e == nil { go f(connection) } } } return } go for the would-be network programmer http://55 slides.games-with-brains.net/
  • 56. package main import . "fmt" import "net" func main() { Listen("tcp", ":1024", func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }) } func Listen(p, a string, f func(net.Conn)) (e error) { var listener net.Listener if listener, e = net.Listen(p, a); e == nil { for { if connection, e := listener.Accept(); e == nil { go f(connection) } } } return } go for the would-be network programmer http://56 slides.games-with-brains.net/
  • 57. package main import . "fmt" import "net" func main() { Listen("tcp", ":1024", func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }) } func Listen(p, a string, f func(net.Conn)) (e error) { var listener net.Listener if listener, e = net.Listen(p, a); e == nil { for { if connection, e := listener.Accept(); e == nil { go f(connection) } } } return } go for the would-be network programmer http://57 slides.games-with-brains.net/
  • 58. package main import . "fmt" import "net" func main() { Listen("tcp", ":1024", func(c net.Conn) { defer c.Close() Fprintln(c, "hello world") }) } func Listen(p, a string, f func(net.Conn)) (e error) { var listener net.Listener if listener, e = net.Listen(p, a); e == nil { for { if connection, e := listener.Accept(); e == nil { go f(connection) } } } return } go for the would-be network programmer http://58 slides.games-with-brains.net/
  • 59. package main import "bufio" import . "fmt" import "net" func main() { if c, e := net.Dial("tcp", ":1024"); e == nil { defer c.Close() if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } } } go for the would-be network programmer http://59 slides.games-with-brains.net/
  • 60. package main import "bufio" import . "fmt" import "net" func main() { if c, e := net.Dial("tcp", ":1024"); e == nil { defer c.Close() if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } } } go for the would-be network programmer http://60 slides.games-with-brains.net/
  • 61. package main import "bufio" import . "fmt" import "net" func main() { if c, e := net.Dial("tcp", ":1024"); e == nil { defer c.Close() if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } } } go for the would-be network programmer http://61 slides.games-with-brains.net/
  • 62. package main import "bufio" import . "fmt" import "net" func main() { if c, e := net.Dial("tcp", ":1024"); e == nil { defer c.Close() if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } } } go for the would-be network programmer http://62 slides.games-with-brains.net/
  • 63. package main import "bufio" import . "fmt" import "net" func main() { if c, e := net.Dial("tcp", ":1024"); e == nil { defer c.Close() if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } } } go for the would-be network programmer http://63 slides.games-with-brains.net/
  • 64. package main import "bufio" import . "fmt" import "net" func main() { if c, e := net.Dial("tcp", ":1024"); e == nil { defer c.Close() if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } } } go for the would-be network programmer http://64 slides.games-with-brains.net/
  • 65. package main import "bufio" import . "fmt" import "net" func main() { Dial("tcp", ":1024", func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } go for the would-be network programmer http://65 slides.games-with-brains.net/
  • 66. package main import "bufio" import . "fmt" import "net" func main() { Dial("tcp", ":1024", func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } func Dial(p, a string, f func(net.Conn)) (e error) { var c net.Conn if c, e = net.Dial(p, a); e == nil { defer c.Close() f(c) } return } go for the would-be network programmer http://66 slides.games-with-brains.net/
  • 67. package main import "bufio" import . "fmt" import "net" func main() { Dial("tcp", ":1024", func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } func Dial(p, a string, f func(net.Conn)) (e error) { var c net.Conn if c, e = net.Dial(p, a); e == nil { defer c.Close() f(c) } return } go for the would-be network programmer http://67 slides.games-with-brains.net/
  • 68. package main import "bufio" import . "fmt" import "net" func main() { Dial("tcp", ":1024", func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } func Dial(p, a string, f func(net.Conn)) (e error) { var c net.Conn if c, e = net.Dial(p, a); e == nil { defer c.Close() f(c) } return } go for the would-be network programmer http://68 slides.games-with-brains.net/
  • 69. package main import "bufio" import . "fmt" import "net" func main() { Dial("tcp", ":1024", func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } func Dial(p, a string, f func(net.Conn)) (e error) { var c net.Conn if c, e = net.Dial(p, a); e == nil { defer c.Close() f(c) } return } go for the would-be network programmer http://69 slides.games-with-brains.net/
  • 70. tcp/tls go for the would-be network programmer 70 http://slides.games-with-brains.net/
  • 71. package main import "crypto/tls" import . "fmt" func main() { Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) { Fprintln(c, "hello world") }) } go for the would-be network programmer http://71 slides.games-with-brains.net/
  • 72. package main import "crypto/tls" import . "fmt" func main() { Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) { Fprintln(c, "hello world") }) } go for the would-be network programmer http://72 slides.games-with-brains.net/
  • 73. package main import "crypto/tls" import . "fmt" func main() { Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) { Fprintln(c, "hello world") }) } go for the would-be network programmer http://73 slides.games-with-brains.net/
  • 74. package main import "crypto/rand" import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, Rand: rand.Reader, } } return } go for the would-be network programmer http://74 slides.games-with-brains.net/
  • 75. package main import "crypto/rand" import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, Rand: rand.Reader, } } return } go for the would-be network programmer http://75 slides.games-with-brains.net/
  • 76. package main import "crypto/rand" import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, Rand: rand.Reader, } } return } go for the would-be network programmer http://76 slides.games-with-brains.net/
  • 77. package main import "crypto/rand" import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, Rand: rand.Reader, } } return } go for the would-be network programmer http://77 slides.games-with-brains.net/
  • 78. package main import "crypto/rand" import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, Rand: rand.Reader, } } return } go for the would-be network programmer http://78 slides.games-with-brains.net/
  • 79. package main import "crypto/tls" func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { if listener, e := tls.Listen("tcp", a, conf); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c *tls.Conn) { defer c.Close() f(c) }(connection.(*tls.Conn)) } } } } go for the would-be network programmer http://79 slides.games-with-brains.net/
  • 80. package main import "crypto/tls" func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { if listener, e := tls.Listen("tcp", a, conf); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c *tls.Conn) { defer c.Close() f(c) }(connection.(*tls.Conn)) } } } } go for the would-be network programmer http://80 slides.games-with-brains.net/
  • 81. package main import "crypto/tls" func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { if listener, e := tls.Listen("tcp", a, conf); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c *tls.Conn) { defer c.Close() f(c) }(connection.(*tls.Conn)) } } } } go for the would-be network programmer http://81 slides.games-with-brains.net/
  • 82. package main import "crypto/tls" func Listen(a string, conf *tls.Config, f func(*tls.Conn)) { if listener, e := tls.Listen("tcp", a, conf); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c *tls.Conn) { defer c.Close() f(c) }(connection.(*tls.Conn)) } } } } go for the would-be network programmer http://82 slides.games-with-brains.net/
  • 83. package main import “crypto/tls" import "net" func Listen(a string, conf *tls.Config, f func(net.Conn)) { if listener, e := tls.Listen("tcp", a, conf); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() f(c) }(connection) } } } } go for the would-be network programmer http://83 slides.games-with-brains.net/
  • 84. package main import "crypto/tls" import "net" func Listen(a string, conf *tls.Config, f func(net.Conn)) { if listener, e := tls.Listen("tcp", a, conf); e == nil { for { if connection, e := listener.Accept(); e == nil { go func(c net.Conn) { defer c.Close() f(c) }(connection) } } } } go for the would-be network programmer http://84 slides.games-with-brains.net/
  • 85. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } go for the would-be network programmer http://85 slides.games-with-brains.net/
  • 86. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } go for the would-be network programmer http://86 slides.games-with-brains.net/
  • 87. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) { if m, e := bufio.NewReader(c).ReadString('n'); e == nil { Printf(m) } }) } go for the would-be network programmer http://87 slides.games-with-brains.net/
  • 88. package main import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, InsecureSkipVerify: true, } } return } go for the would-be network programmer http://88 slides.games-with-brains.net/
  • 89. package main import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, InsecureSkipVerify: true, } } return } go for the would-be network programmer http://89 slides.games-with-brains.net/
  • 90. package main import "crypto/tls" func ConfigTLS(c, k string) (r *tls.Config) { if cert, e := tls.LoadX509KeyPair(c, k); e == nil { r = &tls.Config{ Certificates: []tls.Certificate{ cert }, InsecureSkipVerify: true, } } return } go for the would-be network programmer http://90 slides.games-with-brains.net/
  • 91. package main import “crypto/tls" import "net" func Dial(a string, conf *tls.Config, f func(net.Conn)) { if c, e := tls.Dial("tcp", a, conf); e == nil { defer c.Close() f(c) } } go for the would-be network programmer http://91 slides.games-with-brains.net/
  • 92. package main import “crypto/tls" import "net" func Dial(a string, conf *tls.Config, f func(net.Conn)) { if c, e := tls.Dial("tcp", a, conf); e == nil { defer c.Close() f(c) } } go for the would-be network programmer http://92 slides.games-with-brains.net/
  • 93. udp go for the would-be network programmer 93 http://slides.games-with-brains.net/
  • 94. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://94 slides.games-with-brains.net/
  • 95. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn”) Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://95 slides.games-with-brains.net/
  • 96. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://96 slides.games-with-brains.net/
  • 97. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://97 slides.games-with-brains.net/
  • 98. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://98 slides.games-with-brains.net/
  • 99. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://99 slides.games-with-brains.net/
  • 100. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://100 slides.games-with-brains.net/
  • 101. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://101 slides.games-with-brains.net/
  • 102. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://102 slides.games-with-brains.net/
  • 103. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://103 slides.games-with-brains.net/
  • 104. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://104 slides.games-with-brains.net/
  • 105. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://105 slides.games-with-brains.net/
  • 106. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://106 slides.games-with-brains.net/
  • 107. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://107 slides.games-with-brains.net/
  • 108. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://108 slides.games-with-brains.net/
  • 109. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://109 slides.games-with-brains.net/
  • 110. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://110 slides.games-with-brains.net/
  • 111. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://111 slides.games-with-brains.net/
  • 112. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://112 slides.games-with-brains.net/
  • 113. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://113 slides.games-with-brains.net/
  • 114. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://114 slides.games-with-brains.net/
  • 115. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://115 slides.games-with-brains.net/
  • 116. package main import "bufio" import . "fmt" import "net" func main() { Dial(":1024", func(conn net.Conn) { if _, e := conn.Write([]byte("n")); e == nil { if m, e := bufio.NewReader(conn).ReadString('n'); e == nil { Printf("%v", m) } } }) } func Dial(a string, f func(net.Conn)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() f(conn) } } } go for the would-be network programmer http://116 slides.games-with-brains.net/
  • 117. rsa go for the would-be network programmer 117 http://slides.games-with-brains.net/
  • 118. package main import "net" func main() { HELLO_WORLD := []byte("Hello Worldn") Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { c.WriteToUDP(HELLO_WORLD, a) }) } func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.ListenUDP("udp", address); e == nil { for b := make([]byte, 1024); ; b = make([]byte, 1024) { if n, client, e := conn.ReadFromUDP(b); e == nil { go f(conn, client, b[:n]) } } } } return } go for the would-be network programmer http://118 slides.games-with-brains.net/
  • 119. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://119 slides.games-with-brains.net/
  • 120. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://120 slides.games-with-brains.net/
  • 121. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://121 slides.games-with-brains.net/
  • 122. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://122 slides.games-with-brains.net/
  • 123. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://123 slides.games-with-brains.net/
  • 124. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://124 slides.games-with-brains.net/
  • 125. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://125 slides.games-with-brains.net/
  • 126. package main import . "bytes" import "crypto/rsa" import "encoding/gob" import "net" func main() { HELLO_WORLD := []byte("Hello World") RSA_LABEL := []byte("served") Listen(":1025", func(c *net.UDPConn, a *net.UDPAddr, b []byte) { var key rsa.PublicKey if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil { if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil { c.WriteToUDP(m, a) } } return }) } go for the would-be network programmer http://126 slides.games-with-brains.net/
  • 127. package main import "crypto/rand" import "crypto/rsa" import "crypto/sha1" func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) } go for the would-be network programmer http://127 slides.games-with-brains.net/
  • 128. package main import "crypto/rand" import "crypto/rsa" import "crypto/sha1" func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) } go for the would-be network programmer http://128 slides.games-with-brains.net/
  • 129. package main import "crypto/rand" import "crypto/rsa" import "crypto/sha1" func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) } go for the would-be network programmer http://129 slides.games-with-brains.net/
  • 130. package main import "crypto/rand" import "crypto/rsa" import "crypto/sha1" func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) } go for the would-be network programmer http://130 slides.games-with-brains.net/
  • 131. package main import "crypto/rand" import "crypto/rsa" import "crypto/sha1" func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) { return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l) } go for the would-be network programmer http://131 slides.games-with-brains.net/
  • 132. package main import "crypto/rsa" import . "fmt" import "net" func main() { Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { if m, e := ReadStream(c); e == nil { if m, e := Decrypt(k, m, []byte("served")); e == nil { Println(string(m)) } } }) } go for the would-be network programmer http://132 slides.games-with-brains.net/
  • 133. package main import "crypto/rsa" import . "fmt" import "net" func main() { Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { if m, e := ReadStream(c); e == nil { if m, e := Decrypt(k, m, []byte("served")); e == nil { Println(string(m)) } } }) } go for the would-be network programmer http://133 slides.games-with-brains.net/
  • 134. package main import "crypto/rsa" import . "fmt" import "net" func main() { Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { if m, e := ReadStream(c); e == nil { if m, e := Decrypt(k, m, []byte("served")); e == nil { Println(string(m)) } } }) } go for the would-be network programmer http://134 slides.games-with-brains.net/
  • 135. package main import "crypto/rand" import "crypto/rsa" import "crypto/sha1" func Decrypt(key *rsa.PrivateKey, m, l []byte) ([]byte, error) { return rsa.DecryptOAEP(sha1.New(), rand.Reader, key, m, l) } go for the would-be network programmer http://135 slides.games-with-brains.net/
  • 136. package main import "crypto/rsa" import . "fmt" import "net" func main() { Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { if m, e := ReadStream(c); e == nil { if m, e := Decrypt(k, m, []byte("served")); e == nil { Println(string(m)) } } }) } go for the would-be network programmer http://136 slides.games-with-brains.net/
  • 137. package main import "net" func ReadStream(conn *net.UDPConn) (r []byte, e error) { m := make([]byte, 1024) var n int if n, e = conn.Read(m); e == nil { r = m[:n] } return } go for the would-be network programmer http://137 slides.games-with-brains.net/
  • 138. package main import "net" func ReadStream(conn *net.UDPConn) (r []byte, e error) { m := make([]byte, 1024) var n int if n, e = conn.Read(m); e == nil { r = m[:n] } return } go for the would-be network programmer http://138 slides.games-with-brains.net/
  • 139. package main import "net" func ReadStream(conn *net.UDPConn) (r []byte, e error) { m := make([]byte, 1024) var n int if n, e = conn.Read(m); e == nil { r = m[:n] } return } go for the would-be network programmer http://139 slides.games-with-brains.net/
  • 140. package main import "net" func ReadStream(conn *net.UDPConn) (r []byte, e error) { m := make([]byte, 1024) var n int if n, e = conn.Read(m); e == nil { r = m[:n] } return } go for the would-be network programmer http://140 slides.games-with-brains.net/
  • 141. package main import "crypto/rsa" import . "fmt" import "net" func main() { Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) { if m, e := ReadStream(c); e == nil { if m, e := Decrypt(k, m, []byte("served")); e == nil { Println(string(m)) } } }) } go for the would-be network programmer http://141 slides.games-with-brains.net/
  • 142. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://142 slides.games-with-brains.net/
  • 143. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://143 slides.games-with-brains.net/
  • 144. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://144 slides.games-with-brains.net/
  • 145. package main import "crypto/rsa" import "crypto/x509" import "encoding/pem" import "io/ioutil" func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { if file, e := ioutil.ReadFile(file); e == nil { if block, _ := pem.Decode(file); block != nil { if block.Type == "RSA PRIVATE KEY" { r, e = x509.ParsePKCS1PrivateKey(block.Bytes) } } } return } go for the would-be network programmer http://145 slides.games-with-brains.net/
  • 146. package main import "crypto/rsa" import "crypto/x509" import "encoding/pem" import "io/ioutil" func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { if file, e := ioutil.ReadFile(file); e == nil { if block, _ := pem.Decode(file); block != nil { if block.Type == "RSA PRIVATE KEY" { r, e = x509.ParsePKCS1PrivateKey(block.Bytes) } } } return } go for the would-be network programmer http://146 slides.games-with-brains.net/
  • 147. package main import "crypto/rsa" import "crypto/x509" import "encoding/pem" import "io/ioutil" func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { if file, e := ioutil.ReadFile(file); e == nil { if block, _ := pem.Decode(file); block != nil { if block.Type == "RSA PRIVATE KEY" { r, e = x509.ParsePKCS1PrivateKey(block.Bytes) } } } return } go for the would-be network programmer http://147 slides.games-with-brains.net/
  • 148. package main import "crypto/rsa" import "crypto/x509" import "encoding/pem" import "io/ioutil" func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { if file, e := ioutil.ReadFile(file); e == nil { if block, _ := pem.Decode(file); block != nil { if block.Type == "RSA PRIVATE KEY" { r, e = x509.ParsePKCS1PrivateKey(block.Bytes) } } } return } go for the would-be network programmer http://148 slides.games-with-brains.net/
  • 149. package main import "crypto/rsa" import "crypto/x509" import "encoding/pem" import "io/ioutil" func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { if file, e := ioutil.ReadFile(file); e == nil { if block, _ := pem.Decode(file); block != nil { if block.Type == "RSA PRIVATE KEY" { r, e = x509.ParsePKCS1PrivateKey(block.Bytes) } } } return } go for the would-be network programmer http://149 slides.games-with-brains.net/
  • 150. package main import "crypto/rsa" import "crypto/x509" import "encoding/pem" import "io/ioutil" func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) { if file, e := ioutil.ReadFile(file); e == nil { if block, _ := pem.Decode(file); block != nil { if block.Type == "RSA PRIVATE KEY" { r, e = x509.ParsePKCS1PrivateKey(block.Bytes) } } } return } go for the would-be network programmer http://150 slides.games-with-brains.net/
  • 151. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://151 slides.games-with-brains.net/
  • 152. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://152 slides.games-with-brains.net/
  • 153. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://153 slides.games-with-brains.net/
  • 154. package main import "bytes" import “crypto/rsa" import "encoding/gob" import "net" func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) { var b bytes.Buffer if e := gob.NewEncoder(&b).Encode(k); e == nil { if _, e = c.Write(b.Bytes()); e == nil { f() } } } go for the would-be network programmer http://154 slides.games-with-brains.net/
  • 155. package main import "bytes" import “crypto/rsa" import "encoding/gob" import "net" func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) { var b bytes.Buffer if e := gob.NewEncoder(&b).Encode(k); e == nil { if _, e = c.Write(b.Bytes()); e == nil { f() } } } go for the would-be network programmer http://155 slides.games-with-brains.net/
  • 156. package main import "bytes" import “crypto/rsa" import "encoding/gob" import "net" func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) { var b bytes.Buffer if e := gob.NewEncoder(&b).Encode(k); e == nil { if _, e = c.Write(b.Bytes()); e == nil { f() } } } go for the would-be network programmer http://156 slides.games-with-brains.net/
  • 157. package main import "crypto/rsa" import . "fmt" import "net" func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) { if k, e := LoadPrivateKey(file); e == nil { if address, e := net.ResolveUDPAddr("udp", a); e == nil { if conn, e := net.DialUDP("udp", nil, address); e == nil { defer conn.Close() SendKey(conn, k.PublicKey, func() { f(conn, k) }) } } } } go for the would-be network programmer http://157 slides.games-with-brains.net/
  • 158. http://golang.org/ go for the would-be network programmer http://158 slides.games-with-brains.net/
  • 159. twitter://#golang go for the would-be network programmer http://159 slides.games-with-brains.net/