Table of contents

Go, coding language, introduction to variables and data types

Go, coding language, introduction to variables and data types

Golang, also known as go, is a compiled programming language developed by Google. It is a language quite appreciated according to the latest Stackoverflow surveys (2021), as you can see in my python vs go post, where I also compare the good, the bad and the ugly of this language.

What’s Go the programming language?

Go or Golang is a language with a syntax similar to that of C and with certain abstractions in its syntax that make it a language in which writing code is a piece of cake, the truth is that the feeling is a mixture between C and Python.

This is a compiled, imperative, strongly concurrency-centric, statically typed language.

Cool aspects and advantages of go

  • The language is quite simple** It is a language with just a few keywords and functionalities. You can learn it in a breeze.
  • Go compiler is super fast** Since it has few keywords and the language is quite simple, go compiles rapidly compared to other programming languages.
  • Concurrency handling is easy** Go was designed as a concurrent language, creating concurrency with goroutines is quite easy.
  • Creating web applications is quite simple** Go incorporates in its standard library a lot of utilities to create web servers, so you can even use it without using any framework, for simple applications, and you won’t have any problem.

Why does go suck? Disadvantagesof Go

To make this analysis as objective as possible, here are some controversial aspects of go that are not viewed favorably by some developers.

  • Go lacks support for classes directly. But all is not lost, because it does have certain features that provide it with OOP functionalities, such as polymorphism and classes, by means of interfaces, structs and embedded values.
  • Go does not have exception handling with try and catch blocks or equivalent, but errors must be returned as a return value in a function and are handled by checking that it is not null (nil), by means of if blocks. This can become quite verbose and repetitive.

Error handling with Go with if
This pattern is quite recurrent in applications and can become tedious.

  • There are no default arguments in go, which increases the amount of code to write to deal with defaults.
  • No manual memory management, go uses a garbage collector, which simplifies memory management enormously, but limits more granular memory management, this was one of the reasons why discord migrated from Go to Rust.
  • Go does not have generics Go already has generics support since version 1.18.

Go and its best practices

Go is strongly oriented to good code practices. How does it do it? The compiler forces good practices in the code, preventing the code from compiling if there are variables or imports that are not used, or if the privacy rules of our properties and functions are not respected, among others.

Compilation error in go due to unused variables
Compilation is not allowed if there are unused variables.

The official mascot is a ground squirrel and it is popular among the community to use it to illustrate go-related content. This Sartre in blue rodent version is so popular among developers that there are tools, such as Gopherizme, to create custom avatars. The impact of the mascot is such that many developers use it as a logo, although the official go logo has already been defined.

Go mascot and logo
On the left the Go mascot. On the right the official logo

Installation

Go can be found in most GNU/Linux distribution repositories. In debian and ubuntu it is installed using the apt install command like any other package.

sudo apt install golang

The installation instructions for Freebsd, windows and macOSx will be different.

Structure of a go file

The go files are structured as follows and in this order:

Package name

A section where the package name is declared after the word package. The package name will be used to import our modules.

package main

Imports

A section where all the go packages that will be used are imported. For this we use the word import.

import “fmt” import “fmt” import “fmt” import “fmt” import

Multiple imports can be placed inside parentheses, without commas.

import (
    "strconv"
    "fmt"
)

Content

The contents of the file, i.e. declarations of variables, types, functions, constants, etc.

func main() {
    fmt.Println("Hello world!")
}

The main package

Go requires a main package called main, which will be specified by placing package main at the beginning of our source code.

package main

The main function

The main function is the starting point of a go file, as it would be in C, and returns nothing.

package main

import "fmt"

func main() {
    fmt.Println("Ejecutando el programa")
}

init function

Before the entry point of the program (the main function) an init function is executed, this can contain all the initializations necessary for the execution of the program.

package main

import "fmt"

func init() {
    fmt.Println("Inicializando el programa principal")
}

func main() {
    fmt.Println("Ejecutando el programa")
}

Compiling and running a go file

Since go is a compiled language, it requires the compilation of the code before the code can be executed. Compiling is done with the build command.

go build src/main.go

After the compilation we will have a file that we will be able to execute.

./main

It is also possible to compile and run the code in one step using run instead of go.

go run src/main.go

Differences between run and build

The difference between build and run is that run compiles the code and executes it from a temporary directory, and then cleans up the generated files. If we add the –work flag, we can see the location of this directory.

go run --work src/main.go
# WORK=/tmp/go-build983014220

Primitive data types

Since we are dealing with a compiled language, we need to tell the compiler the data type we will use for each variable or constant.

The primitive values of Go are as follows.

Integer

For signed or unsigned integer values.

  • int, assigned according to OS (32 or 64 bits)
  • int8,
  • int16
  • int32
  • int64

Unsigned integer

For unsigned, i.e. positive values.

  • uint, assigned according to OS (32 or 64 bits)
  • uint8
  • uint16
  • uint32
  • uint64

Decimal

For decimal numbers

  • float32
  • float64

Texts

For text there is only string

Boolean

For true or false values

Complex numbers

It allows to handle real and imaginary numbers:

  • Complex64
  • Complex128

For example: c:=100+2i

Variables, constants and zero values in go

Variables

Go allows you to define variables by specifying the data type and the keyword var. It is as if you added the data type to a Javascript variable declaration.

var gravedad int8

Variable assignment can be performed in a single step as follows:

var gravedad int = 123

It is also possible to let the compiler intuit the data type with the walrus (groundhog) operator. This type of assignment is only possible within the scope of a function.

gravedad := 123

In go you cannot assign a variable to the null value; nil.

var gravedad = nil // error

Constants

Constants work in a similar way, but are characterized by the fact that they cannot be modified. The keyword const is used.

It is necessary to assign a value to a constant when declaring it.

const gravedad int8 = 123

If we do not specify a constant type the compiler will try to guess it.

const pi = 3.14159

Zero values

In go, if we do not assign a value the compiler will use default values for each data type.

  • int: 0
  • float: 0
  • string: "
  • bool: false

Null value

Go uses the reserved word nil to refer to a null value.

Comments

The comments are marked using two diagonals in a row.

// Este es un comentario en go

Multi-line comments are made with a diagonal followed by an asterisk.

/*
Este es un comentario multilinea
*/

Operators in go

The operators of go are similar to the rest of the languages.

  • +, sum
  • -, subtraction
  • *, multiplication
  • /, division
  • <, less than
  • <=, less than or equal to
  • >, greater than
  • >=, greater than or equal to
  • %, modulus or remainder
  • !=, inequivalence
  • ==, equality
  • !, negation
  • &&, AND operator
  • ||, OR operator
  • ++, incremental
  • --, decremental

With this I finish the most basic part of the language, in the next post I will talk about functions and the fmt-package in go, and in a future post about other aspects such as runes, array, slices in go and other features of the language.

Eduardo Zepeda
Web developer and GNU/Linux enthusiast always learning something new. I believe in choosing the right tool for the job and that simplicity is the ultimate sophistication. I'm under the impression that being perfect is the enemy of getting things done. I also believe in the goodnesses of cryptocurrencies outside of monetary speculation.
Read more