How to slice a rune in Go
March 16, 2015
0 comments Go
Strangely this was hard. The solution looks easy but it took me a lot of time to get this right.
What I want to do is split a string up into a slice of parts. For example:
word := "peter"
for i := 1; i <= len(word); i++ {
fmt.Println(word[0:i])
}
The output is:
p pe pet pete peter
Now, what if the word you want to split contains non-ascii characters? As a string "é" is two characters internally. So you can't split them up. See this play and press "Run".
So, the solution is to iterate over the string and Go will give you an index of each unicode character. But you'll want to skip the first one.
word := "péter"
for i, _ := range word {
if i > 0 {
fmt.Println(word[0:i])
}
}
fmt.Println(word)
You can play with it here in this play.
Now the output is the same as what we got in the first example but with unicode characters in it.
p pé pét péte péter
I bet this is obvious to the gurus who've properly read the documentation but it certainly took me some time to figure it out and so I thought I'd share it.
My favorite Go multiplexer
January 28, 2015
7 comments Go
When you write a Go webapp, you need to pick web "middleware" and a multiplexer. If you're used to things like Ruby on Rails or Django, they come with their own multiplexer built in. Also known as a router or URL router.
It's basically where you say...
If a request comes in with PATH that matches /some/page/:id then execute the SomePageHandler. And in SomePageHandler you want to get the actual value for that :id part of the PATH.
Anyway, in Go you're spoiled for choices and it took me some time to understand why there are so many and not just one blessed one. The reason for that is that they evolve and often in favor of getting faster and faster.
90% of the time, the I/O is the limiting factor in terms of performance, not the multiplexer, but if you have an endpoint that doesn't depend on much I/O and you're expecting hefty amounts of traffic then why chose a second best?
I first used gorilla/mux because that's what I saw being used in several places. It's very capable and makes it easy to specify which methods should be allowed for specific routes. A good thing about gorilla/mux
is that it's compatible with the built-in http.Handler API. That means that can write a handler function that whose signature is w http.ResponseWriter, r *http.Request
and if you want to get something out of the path you use vars := mux.Vars(request)
. For example:
package main
import (
"fmt"
"github.com/codegangsta/negroni"
"github.com/gorilla/mux"
"net/http"
)
func MyHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
fmt.Fprintf(w, "Hello %v\n", vars["id"])
}
func main() {
mux := mux.NewRouter()
mux.HandleFunc("/some/page/{id}", MyHandler).Methods("GET")
n := negroni.Classic()
n.UseHandler(mux)
n.Run(":3000")
}
So apparently there's a much faster multiplexer that seems to be popular. It's called httprouter and it's quite pleasant to work with too except that you now have to change your handler to accept a third parameter so it now needs to accept a httprouter.Params
parameter too. So, instead the handler(s) need to change. It looks like this:
package main
import (
"fmt"
"github.com/codegangsta/negroni"
"github.com/julienschmidt/httprouter"
"net/http"
)
func MyHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
fmt.Fprintf(w, "Hello %v\n", ps.ByName("id"))
}
func main() {
mux := httprouter.New()
mux.GET("/some/page/:id", MyHandler)
n := negroni.Classic()
n.UseHandler(mux)
n.Run(":3000")
}
Not too shabby but I can't find out how to do more advanced patterns such as only matching digits e.g. you can do /some/page/{id:[0-9]+}
with gorilla/mux.
There's even a benchmark by the author of httprouter that if it doesn't convince you that httprouter is fast, it'll convince you that there are a lot of multiplexers out there to chose from.
And then there's the new kid on the block. My new favorite: bone
It claims to be very fast too. Its README has a comparison between it and gorilla/mux and httprouter.
What attracted me to it is that it's fast and doesn't require the extract ps httprouter.Params
on all my handlers. Instead you use val := bone.GetValue(req, "id")
within the handler. Here's an example:
package main
import (
"fmt"
"github.com/codegangsta/negroni"
"github.com/go-zoo/bone"
"net/http"
)
func MyHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello %v\n", bone.GetValue(r, "id"))
}
func main() {
mux := bone.New()
mux.Get("/some/page/:id", http.HandlerFunc(MyHandler))
n := negroni.Classic()
n.UseHandler(mux)
n.Run(":3000")
}
Yes, you have to manually wrap every handler function yourself but I don't mind that as much.
Now, for the moment you've all been waiting for, the benchmark.
I take the three sample apps here above and run them with wrk -c 100 -d10 -t10 "http://localhost:3000/some/page/123"
at least three times each. The numbers I get are:
# averages across 3 runs each gorilla/mux 17310.98 requests/sec +0.7% httprouter 19216.08 requests/sec +11.8% bone 17191.12 requests/sec 0%
I also did a similar benchmark but on a piece of code that doesn't use any parameters from the URL and that runs the server across 8 CPUs instead. The numbers I got from that was:
# averages across 3 runs each gorilla/mux 43669.26 requests/sec 0% httprouter 45087.31 requests/sec +3.2% bone 47929.04 requests/sec +9.8%
I think that pretty much concludes that they're all plenty fast. Pick one that you like. I kind like bone
myself because I don't need a third parameter on my handlers and the bone.GetValue(r, "id")
API feels good.
However, httprouter
has much better documentation and feels more mature and newer and fresher than gorilla/mux
.
Go vs. Python
October 24, 2014
42 comments Python, Go
tl;dr; It's not a competition! I'm just comparing Go and Python. So I can learn Go.
So recently I've been trying to learn Go. It's a modern programming language that started at Google but has very little to do with Google except that some of its core contributors are staff at Google.
The true strength of Go is that it's succinct and minimalistic and fast. It's not a scripting language like Python or Ruby but lots of people write scripts with it. It's growing in popularity with systems people but web developers like me have started to pay attention too.
The best way to learn a language is to do something with it. Build something. However, I don't disagree with that but I just felt I needed to cover the basics first and instead of taking notes I decided to learn by comparing it to something I know well, Python. I did this a zillion years ago when I tried to learn ZPT by comparing it DTML which I already knew well.
My free time is very limited so I'm taking things by small careful baby steps. I read through An Introduction to Programming in Go by Caleb Doxey in a couple of afternoons and then I decided to spend a couple of minutes every day with each chapter and implement something from that book and compare it to how you'd do it in Python.
I also added some slightly more full examples, Markdownserver which was fun because it showed that a simple Go HTTP server that does something can be 10 times faster than the Python equivalent.
What I've learned
-
Go is very unforgiving but I kinda like it. It's like Python but with pyflakes switched on all the time.
-
Go is much more verbose than Python. It just takes so much more lines to say the same thing.
-
Goroutines are awesome. They're a million times easier to grok than Python's myriad of similar solutions.
-
In Python, the ability to write to a list and it automatically expanding at will is awesome.
-
Go doesn't have the concept of "truthy" which I already miss. I.e. in Python you can convert a list type to boolean and the language does this automatically by checking if the length of the list is 0.
-
Go gives you very few choices (e.g. there's only one type of loop and it's the
for
loop) but you often have a choice to pass a copy of an object or to pass a pointer. Those are different things but sometimes I feel like the computer could/should figure it out for me. -
I love the little
defer
thing which means I can put "things to do when you're done" right underneath the thing I'm doing. In Python you get thesetry: ...20 lines... finally: ...now it's over...
things. -
The coding style rules are very different but in Go it's a no brainer because you basically don't have any choices. I like that. You just have to remember to use gofmt.
-
Everything about Go and Go tools follow the strict UNIX pattern to not output anything unless things go bad. I like that.
-
godoc.org is awesome. If you ever wonder how a built in package works you can just type it in after
godoc.org
like this godoc.org/math for example. -
You don't have to compile your Go code to run it. You can simply type
go run mycode.go
it automatically compiles it and then runs it. And it's super fast. -
go get
can take a url likegithub.com/russross/blackfriday
and just install it. No PyPI equivalent. But it scares me to depend on peoples master branches in GitHub. What if master is very different when I go get something locally compared to when I run go get weeks/months later on the server?
UPDATE
Here's a similar project comparing Python vs. JavaScript by Ilya V. Schurov