I recently wrote a blog post for CloudFlare about our use of Go . I thought it was worth following up with a bit more detail about why I like Go. In no particular order:1. It's a fun language to write inThat's hard to justify because it's very personal. But to me Go has all the power of C, and all the fun of a scripting language. Go breaks Ousterhout's Dichotomy . Things like slices make doing the sorts of fast pointer-based things I used to do in C safe and fun.And the fact that it's missing exceptions seems like a win because I much prefer dealing with errors when they occur.Variable declaration, particularly using := , means you get on with programming not doing a bunch of typing about types.And, lastly, gofmt means a complete end to code formatting wars. There's one true way.2. CSPI was lucky enough to study at Oxford under Tony Hoare and so Hoare's Communicating Sequential Processes was an important part of the syllabus. And my doctoral thesis is all CSP and occam . CSP is incredibly simple and powerful: processes go ahead and run in parallel until they need to communicate at which point they synchronize on a communication. There's no shared memory.Go takes the ideas of CSP (and of Dijkstra's Guarded Commands ) and replaces Hoare's synchronization with channel-based communication (with synchronization) (this is actually very, very similar to occam). This does two things: it means the synchronization is part of the language (and not something that you do by calling synchronization functions) and that sharing by communication (instead of sharing memory) is natural.Coupling that with goroutines (which are very, very lightweight) means that it's trivial to write concurrent programs without worrying about the usual headaches of threading. As long as communication between the routines is solely done through channels it just works.3. It's ok to blockRecently some languages/frameworks (notably node.js ) have tried to solve performance problems by making extensive use of callbacks (in the form of anonymous functions) so that whenever a system call is in progress the code can disappear off and do work. I think this makes code seriously ugly.The ugliness comes from two things. Firstly, you're forced to write code in what seems like a backwards manner constantly writing callbacks that will do things when some other things are done. And secondly, rather than solving the problem at hand node.js forces the programmer to do extra work all the time. That's a sort of programmer busy work that's essentially useless, since computers should be worrying about those sorts of problems, and programmers should be worried about writing functionality.Go on the other hand allows you to simply block. Create a goroutine to do the work and just do a system call and when it finishes your goroutine can carry on. No need to worry about any underlying implementation.4. Static duck typingGo dispenses with type hierarchies and has a simple notion of an interface which means you get something close to duck typing while getting static, at compile time type safety. This one feature alone means that it feels like a scripting language.5. Rich libraryThe Go library is incredibly rich . Just go look at it. All those library packages are well thought out, clearly documented and performant. Because the library is open source it's easy to dig in and read the code (which is all formatted with gofmt) and see precisely what it does.These libraries are in real-world use at companies like Heroku, Google, StatHat, SmugMug and more. They are ready for prime time.6. Instant buildsI started a company to speed up builds (particularly for C/C++) because build time is an absolute productivity killer for any developer. And slow builds are one of the things that distinguish scripting and system languages. Go completely does away with that by cleverly handling the dependency problem in the compiler making all builds lighting fast.They are so fast the the Go Playground compiles and runs code while you wait.7. No freeThe language is garbage-collected meaning there are no specific memory allocation/deallocation primitives. I used to love doing memory management because it felt like I was doing really useful work. Having seen Go in action I now think it was total busy work.AsideI'm sure some people reading this are going to say "But language FrobBub has had NoduleFoos for years cretin!".You know what, I don't care.What Go has done is brought together a set of features that make it compact, fast, readable, expressive and fun to program in. I've programmed seriously in tons of languages (both functional and not) and Go is the most fun I've had in a long time.