What Makes Go So Different?

Go is currently one of the most desirable languages to use. Here is its secret ingredient for success

13 min readDec 18, 2020

Go vs. other languages (Illustration by Author)

Introduction

Programming languages can clearly be considered as a primary tool in every programmer’s arsenal. Thus, we tend to associate ourselves with the chosen ones. By that, I mean we are forming massive communities, writing articles, making YouTube videos, mascots, and more importantly — memes. Just kidding, and yet it’s hard to deny the existence of some close, almost personal connection between us and these abstract tools.

Gopher look (Illustration by the author using Go’s iconic mascot)

Brief overview

Here are a few theses to give you a taste for it:

Go is different, yet clearly resembling.
Go is distinct, yet featureless.
Go is young, yet widespread already.
Go is small, yet powerful.
Go is simple, yet quite complex.
Go is running on its own, yet as a number of instances.
Go is a language, yet also an idea.

Now let’s explore each of them in depth.

Creation Context

In order to fully comprehend Golang’s nature, let’s dive into the context of its creation. Since at the time Google was facing issues, which it couldn’t overcome with the existing tools, Go was born in a strong need for changes:

“The goals of the Go project were to eliminate the slowness and clumsiness of software development at Google, and thereby to make the process more productive and scalable. The language was designed by and for people who write and read and debug and maintain large software systems.” — Rob Pike, creator of Golang

That’s being said, Go was designed while having a set of particular problems to solve and initially possessing a solid base of the best features from such noble programming languages as C, Pascal, Modula, and Oberon. It also kept in mind useful characteristics of languages — Python, C++, Java, and so on — criticism of which Go was meant to address.

Language Differences

However, it was never about copying what was already great. Rather it was about coming up with a completely new way of dealing with problems, since sometimes in order to solve a problem, it’s required to give up what has proven to be ineffective. And as a result, every major feature of Go has originated mostly from major constraints, such as:

Having deliberately simplified and clear syntax in order to be readable, easy to learn, and get started with.
Having strict, safe, and entirely statically-typed semantics in order to handle static errors at compile time, and speed up execution and build
Having a garbage collector, though very effective one, in order to deal with memory unsafety while keeping a reasonably high speed of execution and proven resource efficiency
Lacking common features and syntax sugar in order to be minimal, precise, and straightforward, since having only one way of solving a particular problem so as to leave only one style of using it, which as a result noticeably speeds up the development, debug, review, and testing processes and makes maintenance much easier
Not having common object-oriented principles such as inheritance, classes, and ordinary interfaces in order to address OOP criticism, which was becoming more and more frequent since the rise of functional-oriented languages, though Go is partly one, too, being a multi-paradigm language. Also, that helps in achieving orthogonality.
Having vendoring (replaced by Go Modules since 1.11), a robust dependency-management system, and its assembler being extremely close to binary code in order to achieve blazing fast builds and afterward be very lightweight and binaries size-efficient. That makes it a perfect match for the microservice architecture pattern and for cloud-native development in general.
Not having a try-catch exception handling. Despite being very controversial and criticized, this is in fact Golang’s really idiomatic way of dealing with errors, which is actually beneficial in many ways: avoiding repetitive error-handling code, keeping control flow efficient and execution fast, keeping code clean and readable, and simplifying code writing and debugging.

As seen, Go’s developers have managed to come up with a greatly efficient system of language-based constraints to achieve some of its greatest characteristics and features. This practice is very impressive in such a way that by using every single constraint, it manages to simultaneously achieve not one but multiple major features at once.

I should point out that the method of basing Go features on its constraints, which I am defining here, is not entirely based on its creators’ quotes, blog-posts, or speeches, the language’s official documentation, or other writer’s articles but is, in fact, my individual way of understanding and describing the nature of Golang as well as its uniqueness. Surely, you can either agree or disagree with the point of my thoughts. It is perfectly fine for you to love or hate it. Furthermore, I encourage you not to believe me but rather to do your own research on the topic.

Also, at this point, it becomes clear that Go is, in fact, unlike other languages, since they are evolving commonly by adding new features, thereafter growing their complexity and becoming convergent. Whereas Go uses an approach to constrain itself in the first place and then stays mostly finite from its very beginning.

“Many newcomers to Go ask for features from languages they know. But those features do not belong in Go — and the language is fixed. Adding features to Go would not make it better, just bigger. That would make Go less interesting by being less different.” — Rob Pike, creator of Golang

Distinct Features

However, that does not necessarily mean that Go is deficient or missing some important functional features. This would, in fact, make programming useless, since why not use an assembly language in the first place. But this isn’t the case with Go. It surely has some features. The thing is, though, that in order to stay simple, Go is very deliberate about not having features that bring more complexity without solving the problem. This is, in fact, one of those things that makes Go “idiomatic,” as it famously used to be called.

Needless features bring complexity without clarity (Drawing by Renee French)

So what about features that have managed to become a part of Go? Well actually, the rule of intentional simplicity is very much acting for them too. And by saying that, I mean that Golang’s creators have done an incredible job of creating what seems to be something so simple and easy to use, while under the hood is actually highly complicated.

“Go is actually complex. It is, in fact, one of the most complicated things I ever worked on, and yet, it feels simple … It requires a lot of design, thinking, implementation work, refinement. Simplicity is the art of hiding complexity!” — Rob Pike, creator of Golang

Let’s have a look at a few “simple” things in Go:

Garbage collector is, in fact, the most simple feature of Go, since it doesn’t have any control interface. Yet also it is reasonably its most complex one because it manages to provide complete memory safety while saving an exceedingly high runtime speed and providing surprising resource efficiency. Bravo to the creators!

Yes, by all means, Go isn’t the fastest programming language, since we have Rust, Julia, C++, and C for sure. But none of these languages have GC and therefore aren’t even close to being as simple as Go — and it isn’t that slow, actually. In most cases, though, this is possible also due to the next exceptionally simple feature.

Concurrent gophers (Illustration by the author using Renee French’s drawings)

Concurrency aka Goroutines is generally known to be the easiest and most straightforward implementation of the concurrency model so far. The process of spawning a new subprocess is, in fact, so simple that it feels more like doing nothing at all. All you need to do is just type go. It just can’t get easier than that, right?
Interfaces are clearly one of Golang’s most distinct and recognizable features. Their unique design solution addresses most of OOP criticism on its own, enables orthogonality and true component architectures while being just a valueless set of methods, which still hides few ingenious design tricks.
Packages. Simply put, they are just awesome. They work seamlessly, without any surprises, and it feels great to use them, too, especially to import ones. By using the go get tool, you can do it from just about anywhere: Gopkg, GitHub, GitLab, BitBucket, even your own hosted repository source since “vanity” imports was introduced. But I guess, you already know the drill … Yep, they are secretly also pretty complicated in order to enable componentization, modularity, scalability, sharing, data hiding, and isolation, and so on.
Standard library of Go contains a ton of great handy features, which proves that Golang is, in fact, a pretty feature-rich language. However, the way they are implemented is something that makes it so unique. For instance, with the use ofimport “net/http” magic package, you’re at once getting all of the above features implemented in an awesome, highly concurrent, crazy easy to use, through a fully production-ready web-server.
Reflection — This one, in particular, isn’t as simple to use as others in this list since it isn’t the most straightforward concept of any programming languages. Go still manages to make most of it, though, while keeping it relatively easy to use.

Reflection can sometimes be intentionally avoided in favor of Golang’s other paradigm, code generation, which in terms of Go ideology is less magical but more clear and efficient. I personally think of it as white magic, though, and surely will advocate its deliberate use, since sometimes, despite being less efficient, reflection can in fact provide some truly magical capabilities.

And there you have it. Golang’s feature set is a result of a thoughtful solution for yet another major language design problem, which requires selecting only the right features without increasing overall language complexity and with keeping its clarity.

Simplicity is very hard to design. It is very complicated to build. But if you get it right, you get what is easy to use. And the success of Go proves it! — Rob Pike, creator of Golang

Application Scope

Okay, so it’s clear now that Go sure has some features. It’s also easy to use, fast, and productive. But where can you be productive with it? What can you actually do with Go?

Some of the classical programming languages, like C# and Java, throughout their existence have managed to make their way in almost all areas of programming applications. So it seems pretty hard to compete with them. Sure it is, but Go doesn’t actually try to do that. It was designed for a specific purpose in mind, so it is by definition not a general purpose language.

However, in reality, it kinda is one.

You see, despite being initially designed by Google to satisfy their development and environment needs, as soon as Go became open source and quickly grew its contributors base, it became clear that developers wanted to use it for a much wider scope. With the release of Go 1, the language is considered to be a general purpose one.

But this wasn’t the end of the Golang generalization process. As its community is becoming massively bigger, it’s expanding Golang’s area of use and continuing to build new tools, packages, frameworks, drivers, API, code generators, and even more awesome stuff that makes new developers believe that Go can indeed become their next main language, too. Just like me!

Let’s then have a look at what Go is capable of:

Cloud-native web-service development, especially microservices using
Go kit, Micro, Gizmo, Kite, Goa, Caddy, and more
REST API development using Gin, Martini, Revel, Gorilla, Beego, and more
RPC API development using gRPC, Twirp, Spiral, Gorilla
GraphQL API development graphql-go, gqlgen, thunder
Serverless functions development using Serverless Framework, Google Cloud Functions, Sparta, Gordon
Web UI development (WebAssembly) using Hugo, Vugu, TinyGo, Vecty
Robotics, IoT, and embedded development using Gobot, Mainflux, TinyGo, EMBD
CLI application development using Cobra, cli
Machine learning and AI development using GoLearn, Gorgonia

And some not particularly obvious use cases:

Mobile app development using gomobile
Desktop app development using Lorca, Wails, Fyne
Game development using Ebiten, Pixel, G3N
Chatbot development for Discord, Telegram, Slack, more
Blockchain and Smart Contracts development

At the moment Golang’s application scope is clearly more oriented to cloud, web, and systems programming. But considering its highly enthusiastic, initiative, and active community, Go is steadily making its way into almost every other field of IT applications.

Final Thoughts

I’ve been using Go in my projects for almost a year now, and by far I’m genuinely very excited about it. It feels pretty amazing to use it, especially when seeing yourself hitting higher levels of productivity with it.

The ideology behind Go is based on the recognition that coding itself is often the least part of the entirety of the development. Thus Go approaches to constrain itself from needless expressiveness to ensure simplicity, clarity, and efficiency of all the subsequent processes, like maintenance, reviewing, reading, and editing, which afterward, also become beneficial for coding as well.

Overall, I think Golang’s developers made an incredible design and implementation work, and as a result, we now have one of the most convenient and cost-effective languages in the game. And since they were seeking a way to increase the speed and efficiency of development and maintenance of large code bases, Go ended up being an ultimate productivity-enhancer tool.

To summarise the essence of Golang’s uniqueness and determine whether this language suits you, I would like to bring my core thesis from Go’s ideology by quoting its creator just one more time:

“There is a fundamental trade-off in Go that was made in a different direction from most other languages, which is: What do you want, a language more fun to write with, or easier to work on and maintain?” — Rob Pike, creator of Golang

Appreciate your attention.
Happy coding!