diff --git a/2013/go4python.slide b/2013/go4python.slide
new file mode 100644
index 0000000..c1ed696
--- /dev/null
+++ b/2013/go4python.slide
@@ -0,0 +1,446 @@
+Go for Pythonistas
+
+Francesc Campoy Flores
+Gopher at Google
+http://campoy.cat
+
+@francesc
+campoy@golang.com
+
+* Goal of this talk
+
+Whetting your appetite for Go
+
+.image go4python/img/gopher.jpg
+
+* My tactics
+
+1. Showing you how Go is like Python.
+
+2. Showing you how Go is _not_ like Python.
+
+* Python, Go, and me
+
+Software Engineer at Google: _Feb_11-Aug_12_
+
+- Lots of C++ and Python.
+
+- SQL to C++ compiler in Python.
+
+Go Developer Relations: _Aug_12_ - `datetime.now()`
+
+- Lots of Go.
+
+* Things I don't like about Python (it'll be short)
+
+* Beautiful and simple
+
+Dynamic typing - nice because it's concise, like Python.
+
+	a = "hello"
+	b = 1
+	# but also
+	a = 2
+
+Static typing - can be verbose, like Java or C++.
+
+	Foo foo = new Foo();
+
+Static typing with inferred types, like Go.
+
+	a := "hello"
+	b := 1
+	// but no
+	a = 2
+
+Statically-typed Python? Check Guido's [[http://www.mypy-lang.org/][mypy]]
+
+* Run time pyrotechnics
+
+.play go4python/dyntyp.py /name/,
+
+I don't want start a flame war here but ...
+
+*100%*code*coverage*is*a*symptom*
+
+- Code coverage should point you to untested cases.
+- Not a way to find typos!
+- 100% code coverage doesn't mean bug free.
+
+* Other things I don't like
+
+- Deploying - managing dependencies.
+
+- Performance - "not too slow" is often not fast enough.
+
+- Magic! (e.g.: `__magic__`: `**kargs`, `__getattr__`)
+
+A list of magic methods in Python:
+
+.link http://www.rafekettler.com/magicmethods.html
+
+* And I *do* like concurrency!
+
+A lot has been said about Python's infamous Global Interpreter Lock.
+
+You should watch [[http://blip.tv/carlfk/mindblowing-python-gil-2243379][Mindblowing Python GIL]], by David Beazley.
+
+* Things I like about Python
+
+* Things I like about Python
+
+- The Zen of Python. ([[http://talks.golang.org/2012/zen.slide#1][Go and the Zen of Python]])
+
+- Hashes and arrays are part of the language.
+
+- The standard library.
+
+- Magic! A bit of code can do a lot.
+
+* A bit of code
+
+* fib.py
+
+Have you ever heard of Fibonacci?
+
+.play go4python/fib.py /fib/,
+
+* fib.go
+
+Something familiar?
+
+.play go4python/fib.go /func/,
+
+* Fibonacci without generators? What?
+
+Python generators are awesome.
+
+.code go4python/fib-gen.py /fib/,/^$/
+
+Mechanically complex.
+
+.play go4python/fib-gen.py /f = fib/,/^$/
+
+But very easy to use.
+
+.play go4python/fib-gen.py /for x/,/^$/
+
+* Python generators
+
+.image go4python/img/fib-py.png 500 320
+
+Note the generator executes concurrently. Hmm... I like concurrency.
+
+* Go concurrency
+
+Based on *goroutines* and *channels*.
+
+- Goroutines: very light processing actors (the gophers).
+
+- Channels: typed, synchronized, thread-safe pipes (the arrows).
+
+.image go4python/img/funnelin.jpg
+
+* "Generator" goroutines
+
+.image go4python/img/fib-go.png 500 350
+
+* "Generator" goroutines
+
+Uses a channel send instead of `yield`.
+
+.code go4python/fib-gen.go /fib/,/^}/
+
+.play go4python/fib-gen.go /main\(/,
+
+* "Generator" goroutines
+
+A more generator-like style:
+
+.play go4python/fib-gen2.go /func/,
+
+* Exercise: generating prime numbers
+
+Write a function that returns a channel and sends the first n prime numbers on
+it.
+
+Given the function `prime`:
+
+.code go4python/genex.go /prime/,/^}/
+
+Use the Go playground:
+
+.link http://golang.org/s/go4py-ex1
+
+* Solution: generating prime numbers
+
+.code go4python/genex.go /primes\(/,/^}/
+
+.play go4python/genex.go /main\(/,
+
+* Exercise: Fibonacci primes
+
+Write a `filterPrimes` function that takes a channel of ints as a
+parameter and returns another channel of ints.
+
+All the prime numbers that `filterPrimes` receives from the input channel are
+sent into the output channel.
+
+Complete this code snippet:
+
+.link http://golang.org/s/go4py-ex2
+
+* Solution: Fibonacci primes
+
+.code go4python/genex2.go /filterPrimes\(/,/^}/
+
+.play go4python/genex2.go /main\(/,
+
+* But there's much more
+
+Goroutines and channels aren't just for generators. They can be used to model
+all kinds of concurrent systems.
+
+To learn more:
+
+- [[http://talks.golang.org/2012/concurrency.slide#1][Concurrency patterns]], by Rob Pike
+
+- [[http://talks.golang.org/2013/advconc.slide#1][Advanced Concurrency Patterns]], by Sameer Ajmani
+
+* Object-oriented Go
+
+* Object-oriented Go
+
+A type declaration.
+
+.code go4python/typesandmethods.go /Name/,/^}/
+
+A method declaration.
+
+.code go4python/typesandmethods.go /String/,/^}/
+
+Constructing a `Name` and using it.
+
+.play go4python/typesandmethods.go /William/,/Print/
+
+* Methods on anything
+
+There's more to types than structs.
+
+.code go4python/typesandmethods.go /SimpleName/
+
+You can define methods on any type.
+
+.code go4python/typesandmethods.go /SimpleName\)/
+
+Or almost any type.
+
+	func (s string) NoWay()
+
+You can *only* define methods on types within the same package.
+
+* Duck typing
+
+* Duck typing
+
+_If_it_walks_like_a_duck_..._
+
+What defines a duck?
+
+- Is there an explicit list of "duck" features?
+
+- What if the duck is not exactly a duck?
+
+s/duck/file-like object/g
+
+* Quack?
+
+.image go4python/img/duck.jpg 500 500
+
+* Go interfaces
+
+Simply a set of methods.
+
+From the `fmt` package:
+
+	type Stringer interface {
+		String() string
+	}
+
+`fmt.Println` calls the String method if the parameter is a `Stringer`.
+
+.play go4python/typesandmethods.go /second/,/Print/
+
+A type with all the methods of the interface implements the interface.
+
+*Implicit*satisfaction*==*No*"implements"*
+
+Structural typing: it doesn't just sound like a duck, it *is* a duck.
+
+And that's checked at compile time.
+
+* Decorators
+
+* Decorators
+
+A convenient way to wrap a function.
+
+.code go4python/deco.py /auth_required/,/^$/
+
+A function can be decorated using `@`.
+
+.code go4python/deco.py /myHandler/,/user/
+
+* Decorators
+
+If we run it.
+
+.play go4python/deco.py /try/,
+
+This is unauthorized:
+
+.link http://localhost:8080/hi
+
+This is authorized:
+
+.link http://localhost:8080/hi?user=john
+
+* Decorators in Go?
+
+Not exactly, but close enough.
+
+Go doesn't provide decorators in the language, but its function literal syntax and simple scoping rules make it easy to do something similar.
+
+.code go4python/deco.go /hiHandler/,/^\)/
+
+A wrapper function.
+
+.code go4python/deco.go /authRequired/,/^$/
+
+* Decorators in Go?
+
+.play go4python/deco.go /func main/,/^}/
+
+This is unauthorized:
+
+.link http://localhost:8080/hi
+
+This is authorized:
+
+.link http://localhost:8080/hi?user=john
+
+* Exercise: errors in HTTP handlers
+
+In Go, functions can return errors to indicate that something bad happened.
+
+The `net/http` package from the standard library defines the type `HandlerFunc`.
+
+	type HandlerFunc func(ResponseWriter, *Request)
+
+But it's often useful to unify the error handling into a single function to avoid
+repetition.
+
+.code go4python/decoex.go /errorHandler/
+
+Write a decorator that given a `errorHandler` returns a `http.HandlerFunc`.
+If an error occurs it logs it and returns an http error page.
+
+* Exercise: errors in HTTP handlers (continuation)
+
+Given the function `handler`.
+
+.code go4python/decoex.go /handler/,/^}/
+
+We want to use it as follows.
+
+.code go4python/decoex.go /HandleFunc/
+
+Implement `handleError` using the playground.
+
+.link http://golang.org/s/go4py-ex3
+
+* Solution: errors in HTTP handlers
+
+.code go4python/decoex.go /handleError/,/^}/
+
+.code go4python/decoex.go /Fake/,/^$/
+
+.play go4python/decoex.go /john/,/^$/
+
+* Monkey patching
+
+* Monkey patching
+
+"A monkey patch is a way to extend or modify the run-time code of dynamic languages without altering the original source code." - _Wikipedia_
+
+.image go4python/img/monkey.jpg 400 500
+
+* Monkey patching
+
+Also known as "duck punching" ... poor duck.
+
+Often used for testing purposes.
+
+For example, say we want to test this function:
+
+.code go4python/monkey.py /def say_hi/,/^$/
+
+Which depends on a function that makes an HTTP request:
+
+.code go4python/monkey.py /def auth/,/^$/
+
+* Monkey patching
+
+We can test `say_hi` without making HTTP requests by stubbing out `auth`:
+
+.play go4python/monkey.py /sayhitest/,/done/
+
+* Gopher punching!
+
+The same effect can be achieved in Go.
+
+.code go4python/monkey.go /sayHi/,/^}/
+
+Which depends on
+
+.code go4python/monkey.go /auth /,/^}/
+
+* Gopher punching!
+
+Our test code can change the value of auth easily.
+
+.play go4python/monkey.go /TestSayHi/,/^}/
+
+* Conclusion
+
+* Conclusion
+
+Go is a bit like Python
+
+- simple
+- flexible
+- fun
+
+but a bit different too
+
+- fast
+- concurrent
+- statically typed
+
+_Disclaimer_:_
+
+- "No pythons, ducks, monkeys or gophers were harmed while writing this talk"
+
+* Try it
+
+Next steps
+
+.link http://golang.org
+
+Learn Go from your browser
+
+.link http://tour.golang.org
+
+The community: golang-nuts
+
+.link https://groups.google.com/d/forum/golang-nuts
diff --git a/2013/go4python/deco.go b/2013/go4python/deco.go
new file mode 100644
index 0000000..b589a26
--- /dev/null
+++ b/2013/go4python/deco.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func authRequired(f http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.FormValue("user") == "" {
+			http.Error(w, "unknown user", http.StatusForbidden)
+			return
+		}
+		f(w, r)
+	}
+}
+
+var hiHandler = authRequired(
+	func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Hi, %v", r.FormValue("user"))
+	},
+)
+
+func main() {
+	http.HandleFunc("/hi", hiHandler)
+	http.ListenAndServe(":8080", nil)
+}
diff --git a/2013/go4python/deco.py b/2013/go4python/deco.py
new file mode 100644
index 0000000..bf46318
--- /dev/null
+++ b/2013/go4python/deco.py
@@ -0,0 +1,29 @@
+#!/usr/bin/python
+
+from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer
+from urlparse import urlparse,parse_qs
+
+PORT_NUMBER = 8080
+
+def auth_required(myfunc):
+	def checkuser(self):
+		user = parse_qs(urlparse(self.path).query).get('user')
+		if user:
+			self.user = user[0]
+			myfunc(self)
+		else:
+			self.wfile.write('unknown user')
+	return checkuser
+
+
+class myHandler(BaseHTTPRequestHandler):
+	@auth_required
+	def do_GET(self):
+		self.wfile.write('Hello, %s!' % self.user)
+
+try:
+	server = HTTPServer(('', PORT_NUMBER), myHandler)
+	server.serve_forever()
+
+except KeyboardInterrupt:
+	server.socket.close()
diff --git a/2013/go4python/decoex.go b/2013/go4python/decoex.go
new file mode 100644
index 0000000..42725db
--- /dev/null
+++ b/2013/go4python/decoex.go
@@ -0,0 +1,66 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+)
+
+type errorHandler func(http.ResponseWriter, *http.Request) error
+
+func handleError(f errorHandler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		err := f(w, r)
+		if err != nil {
+			log.Printf("%v", err)
+			http.Error(w, "Oops!", http.StatusInternalServerError)
+		}
+	}
+}
+
+func handler(w http.ResponseWriter, r *http.Request) error {
+	name := r.FormValue("name")
+	if name == "" {
+		return fmt.Errorf("empty name")
+	}
+	fmt.Fprintln(w, "Hi,", name)
+	return nil
+}
+
+// resp implements http.ResponseWriter writing
+type dummyResp struct {
+	io.Writer
+	h int
+}
+
+func newDummyResp() http.ResponseWriter {
+	return &dummyResp{Writer: &bytes.Buffer{}}
+}
+
+func (w *dummyResp) Header() http.Header { return make(http.Header) }
+func (w *dummyResp) WriteHeader(h int)   { w.h = h }
+func (w *dummyResp) String() string      { return fmt.Sprintf("[%v] %q", w.h, w.Writer) }
+
+func main() {
+	http.HandleFunc("/hi", handleError(handler))
+
+	// ListenAndServe is not allowed on the playground.
+	// http.ListenAndServe(":8080", nil)
+
+	// In the playground we call the handler manually with dummy requests.
+
+	// Fake request without 'name' parameter.
+	r := &http.Request{}
+	w := newDummyResp()
+	handleError(handler)(w, r)
+	fmt.Println("resp a:", w)
+
+	// Fake request with 'name' parameter 'john'.
+	r.Form["name"] = []string{"john"}
+	w = newDummyResp()
+	handleError(handler)(w, r)
+	fmt.Println("resp b:", w)
+
+}
diff --git a/2013/go4python/dyntyp.py b/2013/go4python/dyntyp.py
new file mode 100644
index 0000000..fa9e4ea
--- /dev/null
+++ b/2013/go4python/dyntyp.py
@@ -0,0 +1,11 @@
+#!/usr/bin/python
+
+import random
+
+name = 'pythonista'
+
+# This code only works half of the time.
+if random.random() > 0.5:
+	print 'hey '+name+', you win!'
+else:
+	print 'sorry '+nane+', you lose'
diff --git a/2013/go4python/fib-gen.go b/2013/go4python/fib-gen.go
new file mode 100644
index 0000000..5142cc7
--- /dev/null
+++ b/2013/go4python/fib-gen.go
@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func fib(c chan int, n int) {
+	a, b := 0, 1
+	for i := 0; i < n; i++ {
+		a, b = b, a+b
+		c <- a // HL
+	}
+	close(c)
+}
+
+func main() {
+	c := make(chan int)
+	go fib(c, 10) // HL
+
+	for x := range c { // HL
+		fmt.Println(x)
+	}
+}
diff --git a/2013/go4python/fib-gen.py b/2013/go4python/fib-gen.py
new file mode 100644
index 0000000..bc02cfd
--- /dev/null
+++ b/2013/go4python/fib-gen.py
@@ -0,0 +1,18 @@
+#!/usr/bin/python
+
+def fib(n):
+    a, b = 0, 1
+    for i in range(n):
+        a, b = b, a + b
+        yield a
+
+f = fib(10)
+try:
+	while True:
+		print f.next()
+except StopIteration:
+	print 'done'
+
+for x in fib(10):
+	print x
+print 'done'
diff --git a/2013/go4python/fib-gen2.go b/2013/go4python/fib-gen2.go
new file mode 100644
index 0000000..9625ba1
--- /dev/null
+++ b/2013/go4python/fib-gen2.go
@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func fib(n int) chan int {
+	c := make(chan int) // HL
+	go func() {         // HL
+		a, b := 0, 1
+		for i := 0; i < n; i++ {
+			a, b = b, a+b
+			c <- a // HL
+		}
+		close(c)
+	}()
+	return c
+}
+
+func main() {
+	for x := range fib(10) {
+		fmt.Println(x)
+	}
+}
diff --git a/2013/go4python/fib.go b/2013/go4python/fib.go
new file mode 100644
index 0000000..dbfef11
--- /dev/null
+++ b/2013/go4python/fib.go
@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func fib(n int) int {
+	a, b := 0, 1
+	for i := 0; i < n; i++ {
+		a, b = b, a+b
+	}
+	return b
+}
+
+func fibRec(n int) int {
+	if n <= 1 {
+		return 1
+	}
+	return fibRec(n-1) + fibRec(n-2)
+}
+
+func main() {
+	for i := 0; i < 10; i++ {
+		fmt.Println(fib(i), fibRec(i))
+	}
+}
diff --git a/2013/go4python/fib.py b/2013/go4python/fib.py
new file mode 100755
index 0000000..afc57fa
--- /dev/null
+++ b/2013/go4python/fib.py
@@ -0,0 +1,16 @@
+#!/usr/bin/python
+
+def fib(n):
+    a, b = 0, 1
+    for i in range(n):
+        a, b = b, a + b
+    return b
+
+def fib_rec(n):
+	if n <= 1:
+		return 1
+	else:
+		return fib_rec(n-1) + fib_rec(n-2)
+
+for x in range(10):
+	print fib(x), fib_rec(x)
diff --git a/2013/go4python/genex.go b/2013/go4python/genex.go
new file mode 100644
index 0000000..6914d5f
--- /dev/null
+++ b/2013/go4python/genex.go
@@ -0,0 +1,35 @@
+package main
+
+import "fmt"
+
+// prime returns true if n is a prime number.
+func prime(n int) bool {
+	for i := 2; i < n; i++ {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// primes returns a channel of ints on which it writes the first n prime
+// numbers before closing it.
+func primes(n int) chan int {
+	c := make(chan int)
+	go func() {
+		for i := 1; n > 0; i++ {
+			if prime(i) {
+				c <- i
+				n--
+			}
+		}
+		close(c)
+	}()
+	return c
+}
+
+func main() {
+	for p := range primes(10) {
+		fmt.Println(p)
+	}
+}
diff --git a/2013/go4python/genex2.go b/2013/go4python/genex2.go
new file mode 100644
index 0000000..50daa06
--- /dev/null
+++ b/2013/go4python/genex2.go
@@ -0,0 +1,48 @@
+package main
+
+import "fmt"
+
+// prime returns true if n is a prime number.
+func prime(n int) bool {
+	for i := 2; i < n; i++ {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// fib returns a channel on which the first n Fibonacci numbers are written.
+func fib(n int) chan int {
+	c := make(chan int)
+	go func() {
+		a, b := 0, 1
+		for i := 0; i < n; i++ {
+			a, b = b, a+b
+			c <- a
+		}
+		close(c)
+	}()
+	return c
+}
+
+// filterPrimes returns a channel of ints on which it writes all the prime
+// numbers read from cin, and closes the returned channel when cin is closed.
+func filterPrimes(cin chan int) chan int {
+	cout := make(chan int)
+	go func() {
+		for v := range cin {
+			if prime(v) {
+				cout <- v
+			}
+		}
+		close(cout)
+	}()
+	return cout
+}
+
+func main() {
+	for p := range filterPrimes(fib(20)) {
+		fmt.Println(p)
+	}
+}
diff --git a/2013/go4python/img/duck.jpg b/2013/go4python/img/duck.jpg
new file mode 100644
index 0000000..344b31e
--- /dev/null
+++ b/2013/go4python/img/duck.jpg
Binary files differ
diff --git a/2013/go4python/img/fib-go.png b/2013/go4python/img/fib-go.png
new file mode 100644
index 0000000..6917140
--- /dev/null
+++ b/2013/go4python/img/fib-go.png
Binary files differ
diff --git a/2013/go4python/img/fib-py.png b/2013/go4python/img/fib-py.png
new file mode 100644
index 0000000..96bad1a
--- /dev/null
+++ b/2013/go4python/img/fib-py.png
Binary files differ
diff --git a/2013/go4python/img/funnelin.jpg b/2013/go4python/img/funnelin.jpg
new file mode 100644
index 0000000..2bf6873
--- /dev/null
+++ b/2013/go4python/img/funnelin.jpg
Binary files differ
diff --git a/2013/go4python/img/gopher.jpg b/2013/go4python/img/gopher.jpg
new file mode 100644
index 0000000..0a64306
--- /dev/null
+++ b/2013/go4python/img/gopher.jpg
Binary files differ
diff --git a/2013/go4python/img/monkey.jpg b/2013/go4python/img/monkey.jpg
new file mode 100644
index 0000000..f4b5569
--- /dev/null
+++ b/2013/go4python/img/monkey.jpg
Binary files differ
diff --git a/2013/go4python/monkey.go b/2013/go4python/monkey.go
new file mode 100644
index 0000000..161180a
--- /dev/null
+++ b/2013/go4python/monkey.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+var authURL = ""
+
+var auth = func(user string) bool {
+	res, err := http.Get(authURL + "/" + user)
+	return err == nil && res.StatusCode == http.StatusOK
+}
+
+func sayHi(user string) {
+	if !auth(user) {
+		fmt.Printf("unknown user %v\n", user)
+		return
+	}
+	fmt.Printf("Hi, %v\n", user)
+}
+
+func TestSayHi() {
+	auth = func(string) bool { return true }
+	sayHi("John")
+
+	auth = func(string) bool { return false }
+	sayHi("John")
+}
+
+func init() {
+	auth = func(string) bool { return true }
+}
+
+func TestAnythingElse() {
+	// auth has been already set to the fake version
+}
+
+func main() {
+	TestSayHi()
+}
diff --git a/2013/go4python/monkey.py b/2013/go4python/monkey.py
new file mode 100644
index 0000000..6f33a7c
--- /dev/null
+++ b/2013/go4python/monkey.py
@@ -0,0 +1,30 @@
+#!/usr/bin/python
+
+import urllib
+
+auth_url = 'http://google.com'
+
+def auth(usr):
+	try:
+		r = urllib.urlopen(auth_url + '/' + usr)
+		return r.getcode() == 200
+	except:
+		return False
+
+def say_hi(usr):
+	if auth(usr):
+		print 'Hi, %s' % usr
+	else:
+		print 'unknown user %s' % usr
+
+def sayhitest():
+	# Test authenticated user
+	globals()['auth'] = lambda x: True
+	say_hi('John')
+
+	# Test unauthenticated user
+	globals()['auth'] = lambda x: False
+	say_hi('John')
+#done OMIT
+
+sayhitest()
diff --git a/2013/go4python/typesandmethods.go b/2013/go4python/typesandmethods.go
new file mode 100644
index 0000000..53bc1e2
--- /dev/null
+++ b/2013/go4python/typesandmethods.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Name struct {
+	First  string
+	Middle string
+	Last   string
+}
+
+func (n Name) String() string {
+	return fmt.Sprintf("%s %c. %s", n.First, n.Middle[0], strings.ToUpper(n.Last))
+}
+
+type SimpleName string
+
+func (s SimpleName) String() string { return string(s) }
+
+func main() {
+	n := Name{"William", "Mike", "Smith"}
+	fmt.Printf("%s", n.String())
+	return
+	// second OMIT
+	n = Name{"William", "Mike", "Smith"}
+	fmt.Println(n)
+}