#gocode

In the recent past, I heard about this new programming language from Google, called “Go”.  Being an avid Counter-Strike player, I was a little put off because Valve named the latest version of CS, “Global Offensive”, or “GO” for short.  I couldn't possibly have two things named “Go” in my life, right?

Well I was wrong.  The Go programming language looks amazing.  Granted it is still young, but the potential for this language is immense.  Here’s the description of Go from their site:

Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.

They say a lot in that little summary.  Let’s break it down a little:

The first claim they make is to Go’s concurrency mechanisms.  In order to understand how big of a deal this really is, you need to understand how concurrency and multi-threaded applications work in a device with more than one processor.  Most applications out there have no performance benefits from running in a multi-core/multi-processor machine.  This is due to the fact that creating multi-threaded applications is so complex and difficult to do.  If you really don’t need to do multi-threading or concurrent processing, it is never worth the effort to build that into the application.  As a result, almost every single device or PC out there today has more than one processor, but almost none of the applications running on these devices can utilize that hardware.

Go is a modern language.  In modern times (such as these?) we shouldn't have such a barrier for creating multi-threaded applications.  Consumers want faster applications, and developers want their applications to be fast.  Granted, not every application needs to be multi-threaded.  If your application is linear in nature, adding concurrency can actually slow things down significantly. The engineers that built the Go language built concurrency into the language, and abstracted it away from the developer code.  This was a huge hurdle for them to overcome.  It’s a huge hurdle for anyone to overcome when trying to incorporate true concurrency into an application.  The software out there that has multi-threaded support today had to overcome these hurdles.  The team behind Go decided that they would do it once, for everyone, and build into the language itself.  Thank you team Go! 

Go also differs from many other languages by including the garbage collection process.  Those who are familiar with .NET languages such as C# will know exactly what garbage collection is and why it is important (and why you love and hate it).  In historical application development, the developer would have to manually control memory assignment.  This means that if you set a variable to a certain value, that value is stored in memory forever until you manually clean it up.  When you don’t clean up those values stored in memory, your application suffers from a memory leak.  Garbage collection works by keeping track of pointers to objects in memory.  When an object in memory is no longer referenced by some other object, the garbage collection process automatically removes that object from memory.  This does not mean that developers can simply ignore their resource usage, but it does help tremendously.  

While we’ve brought up .NET languages, let’s take it a step further.  Until very recently, .NET was a Microsoft technology that could only “officially” run on Windows devices.  Recently, Microsoft announced they would open source .NET, which will make it available to all platforms (as soon as the appropriate compilers are ready).  This is a great move by Microsoft and I applaud them for that.  The benefit of other languages over .NET has always been the cross-platform nature of them.  Applications written in C, C++, and Java can all be compiled and run on virtually any PC.  These languages are the standards for cross-platform development.  Go is also platform agnostic.  In addition, the traditional cross-platform languages are all very fast.  Initial testing of Go compilers show that Go can be close to as fast as the most mature C compilers.  There is a lot of room for Go compilers to mature, so I think the future is very promising from a performance standpoint. 

In conclusion, it’s been a long time since I’ve been so excited about a language.  It’s been out for a little while now, and I’m concerned that the adoption has been too slow.  I would hate to see a beautiful and efficient language such as this go the way of the Dodo.

Der GoCode lautet: 10k

From the README:

Gocode is a helper tool which is intended to be integraded with your source code editor, like vim and emacs. It provides several advanced capabilities, which currently includes:

Context-sensitive autocompletion

It is called daemon, because it uses client/server architecture for caching purposes. In particular, it makes autocompletions very fast. Typical autocompletion time with warm cache is 30ms, which is barely noticeable.