Published: Sat 01 June 2024
By Benoît HERVIER
In misc .
Development experience
Really fast compilation
Clear error message
Go format : Go's formatting rules ensure consistency throughout the codebase, making it easier for developers to read and understand each other's code.
The standard library in Go is very well-provided for, and does not require a heavy-duty web framework.
Retro compatibility of the language : Go 1.x maintains binary compatibility with previous versions,
which means that programs compiled with older Go versions can still run without modification.
Migration to newer version is easy, and actually there is no plan for a version 2.x.
Error management
Go error management is simple and have no exception. Errors are just a type like others.
Go encourages a culture of error management that forces you to handle as they arise.
At first glance, it may seem a bit verbose, but it forces error handling and prevents errors from being swept under the rug.
A sample exemple of error handling :
::: golang
package main
import (
"errors"
"fmt"
)
var ErrDivideByZero = errors . New ( "cannot divide by zero" )
func Divide ( a int , b int ) ( int , error ) {
if b == 0 {
return 0 , ErrDivideByZero
}
return a / b , nil
}
func main () {
result , err := Divide ( 10 , 2 )
if err != nil {
fmt . Println ( err )
return
}
fmt . Printf ( "10 divided by 2 is %d \n " , result )
}
Concurrency
The concurrency : Go has built-in concurrency support through its goroutine and channel mechanisms, which makes it easy to write concurrent code.
A example with a worker pool pattern :
::: golang
package main
import (
"fmt"
"sync"
"time"
)
func main () {
startTime := time . Now ()
totalJobs := 5
jobs := make ( chan int , totalJobs )
var workerGroup sync . WaitGroup
for w := 1 ; w <= 2 ; w ++ {
workerGroup . Add ( 1 )
go worker ( w , jobs , & workerGroup )
}
for job := 1 ; job <= totalJobs ; job ++ {
jobs <- job
}
close ( jobs )
workerGroup . Wait ()
fmt . Printf ( "Total time %d \n " , time . Since ( startTime ))
}
func worker ( w int , jobs chan int , wg * sync . WaitGroup ) {
defer wg . Done ()
for job := range jobs {
processJobs ( w , job )
}
}
func processJobs ( w int , job int ) {
fmt . Printf ( "Worker %d : starting job %d \n " , worker , job )
time . Sleep ( time . Second )
fmt . Printf ( "Worker %d : finished job %d \n " , worker , job )
}
Cross compatibility
Go programs can run on multiple platforms, including Windows, macOS, and Linux, making it a great choice for building cross-platform applications.
They can be compiled into static binaries, which means that the binary code is included in the final executable.
This eliminates the need for dynamic linking or runtime dependencies, making it easier to deploy and run.
The ecosystem
While the Goang ecosystem is not as mature as Python or Java, there are fewer libraries, but the quality is awesome.
The only killer feature missing to Go is a multiplatform GUI, i know GTK and Qt can be an option, but something truely
in the spirit of GO. https://github.com/fyne-io/fyne look like a good start, but also not yet mature.
Just try fyne :
go install fyne . io / fyne / v2 / cmd / fyne_demo @latest
fyne_demo