The Fascinating History of Go

Go’s Origin and Founders

It all starts back in 2007 at Google when Robert Griesemer, Rob Pike, and Ken Thompson began brainstorming a language that could tackle the frustrations they encountered in large-scale software projects.

Trust me when I say this, when it comes to language designers, it doesn’t get better than this team. Robert had previously worked on JavaScript’s V8 engine and on the Java language at Sun Microsystems. Rob helped create the Plan 9 and Inferno operating systems at Bell Labs, and Ken is a legend in the industry well known for co-creating the first version of Unix in 3 weeks and for receiving the Turing Award among many other things.

At the time, Google was growing at an unprecedented rate, which brought unique challenges in code maintainability, speed, and efficiency. Existing languages like C++ and Java were powerful but felt cumbersome in such massive systems, while scripting languages lacked the performance needed at scale.

There is this famous joke in the Go world stating that Golang was created while waiting for C++ to compile. Well, there might be more truth to this than some people are willing to admit. “If it didn’t take 45 minutes to build the binary I was working on at the time Go would not have happened” - Rob Pike

An important distinction to keep in mind is that the original goal was not to create a new programming language, it was to create a better way to write software.

Once you have the idea of a new language the next thing you’ll need is a mascot. Having a recognizable funny creature ready to share the message from day one was vital to Go’s growth. When computer scientists are in charge, of course you’ll get good documentation and guidelines for everything. As a result, Go is probably the only language which has a model sheet for its logo, describing in detail the specification of the Gopher.

Design Philosophy

In the design phase, Go creators had a few clear goals in mind.

First of all, a simple language with clean, concise syntax was the target. This meant reducing keywords to an absolute minimum, avoiding implicit conversions, and favoring composition over inheritance to keep things straightforward.

Second, the idea of scale was crucial both when it came to system performance and the developer experience. So Go routines were designed to allow developers to write concurrent code that scales well. In other words they offer a lightweight way to handle multiple tasks at once, without heavy processing.

On the DX front, Go’s tooling, especially its formatters and linters, was built from the ground up to encourage consistency across codebases.

Next, Go was designed at a time when multi-core CPUs and distributed systems were the new norm, something that older languages like C++ and Java weren’t initially built for. The designers wanted a language that could take full advantage of this hardware evolution, which led to Go’s emphasis on concurrency and efficient performance on network systems.

Finally, one of Go’s standout features is how it combines coding speed with the reliability of a compiled, statically typed language. Its syntax is concise and expressive, similar to Python, making it quick to write and easy to read. Unlike dynamic languages though, Go’s static typing helps catch errors early, reducing runtime issues.

It is worth mentioning that Go comes packed with a powerful garbage collector, which is a bit unusual for a systems language, but we’ll get back to this definition in a minute.

Of course, all these reasons are stated as the official motivation behind the language. In reality, Ken Thomson might have jokingly voiced a far more shallow motivation.

For me the reason I was enthusiastic about Go is because just about the same time we were starting on go I read or tried to read the C++ 0x proposed standard and that was the convincer for me.

So you get the point. Go designers were really not that happy with the complexities of building software, and they wanted smarter, simpler solutions.

What’s interesting is that because of this focus on simplicity, when GO launched, some complained it was missing particular features or methodologies that were regarded as must-haves for any modern language.

Fast forward a few years and in 2012 Go finally reaches version 1, after being officially announced in 2009.

You can see a list of milestones showcasing the long complex process the team went through at that time in a presentation Robert gave for the Go’s 10th anniversary.

Features and Controversies

With version 1 a backwards compatibility promise was introduced, ensuring that Go code would be compatible with future versions of the language. This release also brought the famous and powerful standard library covering everything from HTTP servers to text formatting.

Then, around 2014, thanks to its efficient concurrency model and straightforward syntax, Go became a popular choice for building web servers, APIs, and microservices. What you might not realize is that this shift is actually a huge milestone. Go is no longer viewed as a systems language suited for low level work, and it is slowly getting a wider adoption.

“When we first announced Go we called it a systems programming language, and I slightly regret that because a lot of people assumed that meant it was an operating systems writing language. What we should have called it was a ‘server writing language’, which is what we really thought of it as.”

Either way, Go started as a reaction to the C++ limitations. They weren’t trying to design a better C++, or even a better C. The aim was to create a better language overall for the kind of software they cared about.

Around this time Docker, one of the most successful Go based projects was taking off. Docker brought containerization into the mainstream, and Go was right there in the mix, proving itself in production and on a massive scale. Following Docker’s success, other major projects in cloud infrastructure, such as Kubernetes, and Terraform, also embraced Go.

These tools not only popularized Go within the cloud and DevOps communities but cemented its reputation as a language built for modern, distributed, and scalable systems. In the meantime, Go was also adopted by various big tech companies.

Then, in 2015 another big milestone was reached with the introduction of the Go Compiler. The Compiler is written in Go itself rather than C making the language more self-contained.

The introduction of generics is another highlight in the language’s history, especially since the designers fought against this idea for quite a while.

The recent years marked a steady growth and wider adoption, with Go showing up in various developers surveys as a crowd favorite.

Go is also known for introducing some pretty divisive concepts such as errors as values or composition over inheritance but, in the words of Rob Pike “what’s good and bad in a programming language is largely a matter of opinion rather than fact despite the certainty with which many people argue even the most trivial features”.

Golang’s promise in 2024 is to continue their already existing efforts while exploring new avenues. The Go team is working on making the language better for AI, by enhancing Go’s capabilities in AI infrastructure, applications, and developer assistance.

The reality is that we live in a fast-paced, high-demand software landscape, and the tools you are using matter more than ever. Efficiency is key and you should really consider Go since it makes building production software easier and more productive.

If you want to find out more details about Go you can check some of the other videos on my channel.

Until next time, thank you for reading!