Go Features

Go(or Golang) is an open-source, statically typed programming language, that is only a decade older. Having gained so much popularity lately, it is on its way to becoming one of the most popular languages used worldwide. The reason for its popularity among developers is the variety of features that it offers in comparison to its peer languages. Let's have a look at these features one by one.

Key Features of Go

Here we have some of the key features of the Go language.

Concurrency Support

Concurrency is the ability to deal with multiple things at once, but no two things are happening at the same instance. Go provides rich support to concurrency. Go provides goroutines instead of threads.

Goroutines are much lighter than threads and they are multiplexed onto OS threads, hence enabling Go to achieve the same level of scalability with very few actual OS threads. Also, spawning a goroutine is much easier and one can do this by just putting the go keyword just before a function. For example:

func doSomething(){
    fmt.Println("Print this!")
}

func main(){
    fmt.Println("Inside main")
    doSomething()      // invoking normally
    go doSomething()   // invoking a goroutine
}

Go also provides channels that enable communication between different goroutines. With the help of channels, one goroutine can send/receive the data. These inbuilt features are what make scaling and handling large concurrent applications much better in Go.

Simplicity

Being a simple programming language that is also feature-rich, maintaining a great level of readability and maintainability is not easy for any programming language, but Go does it almost perfectly.

The developers behind Go language only added those features that they thought necessary and which didn't make the language complex to read and write. One of the key examples can be that just by making the name of the function uppercase, the function becomes available to be used in different packages, which is simple and doesn't bring any additional complexity to the language. Along with simplicity, the language remains consistent and contributes a lot when we talk about readability and maintainability.

Powerful Standard Library

Go has a very powerful standard library, which in turn contains a rich set of library packages that developers can use to do a whole variety of tasks. It contains packages that one usually expects to be present in 3rd party libraries.

Testing Support

Go has great Unit testing support. It has the Unit testing built in the language itself. It provides a very simple mechanism that allows us to write unit tests in parallel to the Go code. We can make use of the inbuilt test utilities by just using the go test command and it will allow us to test our code written in *_test.go files.

Powerful Compiler

It is super fast and able to compile a large Go program within few seconds. Go programs are easily parsable without a symbol table.

The simplicity of the syntax of the language plays its role in the quick compilation of the Go program. Also, the compiler invokes a linker at the very last step when compiling a statically linked binary, in turn, result in a faster and more portable binary. The size may be bigger though. Also, the compiler doesn't need any environment such as JVM as it compiles the Go code into native machine code.

Go Binaries

Go allows creating binaries of its applications that also include all their dependencies inside it. This allows remaining free of the tedious way of installing runtimes that are necessary for running our applications.

Conclusion

In this topic, we learned features that make the Go programming language stand apart from other programming languages.