Learning Golang on Fernando Correia's Blog

Learning Golang: Random numbers

Sat, 20 Feb 2021 23:29:42 +0000

This is part 23 of my journey learning Golang.

Random number generators

For some kinds of programs, like simulations, games, or test code, it is useful to be able to generate unpredictable sequences of numbers.

While generating truly random numbers is a hard problem (see RANDOM.ORG), a common alternative is to use a pseudorandom number generator.

Go has a package for generating pseudo-random numbers: rand.

Random integer

The Int() function from the rand package returns a non-negative pseudo-random int.

Learning Golang: Scoped shorthand variable declaration

Sun, 14 Feb 2021 03:24:01 +0000

This is part 22 of my journey learning Golang.

Variable scopes

A common source of errors in programming is using the same variable in many different parts of a program. For a deep dive into the problems that this practice can cause, take a look at Global Variables Are Bad.

A common solution that is adopted by most programming languages is to make it possible to declare variables that can only be used by a subset of the program. For instance, by a single module, class, function, or statement inside of a function. This concept of the area of a program that can use a given identifier is called a “scope”. The smaller the scope, the smaller the amount of logic that can deal with that variable, and the smaller the chance of subtle errors creeping in.

Learning Golang: switch

Sat, 19 Dec 2020 18:59:21 +0000

This is part 21 of my journey learning Golang.

Chained conditions

It is a common pattern for a program to have a sequence of conditional statements testing for different values of the same variable or function result.

For instance:

 1package main
 2
 3import (
 4  "fmt"
 5)
 6
 7func main() {
 8  x := 0
 9  y := 0
10  for command := ""; command != "end"; {
11    fmt.Print("Command? ")
12    fmt.Scan(&command)
13    if command == "up" {
14      y -= 1
15    } else if command == "down" {
16      y += 1
17    } else if command == "left" {
18      x -= 1
19    } else if command == "right" {
20      x += 1
21    } else if command == "end" {
22      fmt.Println("Exiting.")
23    } else {
24      fmt.Printf("Invalid command: %v\n", command)
25    }
26    fmt.Printf("x=%v, y=%v\n", x, y)
27  }
28}

Source: learning-go/switch/if-else.go

Learning Golang: Logical operators

Fri, 09 Oct 2020 03:32:37 +0000

This is part 20 of my journey learning Golang.

Boolean algebra

Boolean algebra is about logical operations applied to the boolean values true and false.

The most common operations are “and” (conjunction), “or” (disjunction) and “not” (negation).

Fun fact: it is called “boolean” because it was introduced by George Boole in 1847.

Logical operators

Go provides three operators for boolean algebra, called “logical operators”:

&&: AND operator.
||: OR operator.
!: NOT operator.

And

The && operator takes two boolean values and it produces true if and only if both its operands are true.

Learning Golang: if and else

Thu, 08 Oct 2020 04:26:15 +0000

This is part 19 of my journey learning Golang.

Conditionals

Any program can be written in terms of three control structures:

the sequence structure, in which expressions are executed in sequence, one after the other, in the order that they are written;
the selection structure, in which a statement can be executed or not, depending on some condition; and
the iteration structure, in which statements may be executed repeatedly until a condition becomes true (or false).

Conditionals are selection structures. The provide a way for expressing decision-making in a program. Depending on the value of an expression, the program may execute (or not) one or more statements.

Learning Golang: Scan, Scanln and Scanf

Sat, 19 Sep 2020 16:09:07 +0000

This is part 18 of my journey learning Golang.

Command line interface

When building programs that run on a terminal it is often useful to be able to allow the user to enter text.

For instance the ssh-keygen utility will prompt for a path and a passphrase.

1❯ ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
2Generating public/private rsa key pair.
3Enter file in which to save the key (/home/fernando/.ssh/id_rsa): /tmp/test_rsa
4Enter passphrase (empty for no passphrase):
5Enter same passphrase again:

Scan

The Scan method of the fmt package will read a single space-separated token (like a single word) from the standard input device (which is usually the console).

Learning Golang: Sprint, Sprintln, Sprintf

Wed, 16 Sep 2020 03:09:15 +0000

This is part 17 of my journey learning Golang.

The fmt package has methods like Print, Println and Printf to print text to the standard output device.

It also has corresponding methods that return the strings that would be printed out, instead of actually printing them out. Afterwards the program can use the returned values for any purpose like for instance sending an email or creating a PDF file.

Sprint

Returns a string containing the input arguments. No spaces or new line characters are added automatically.

Learning Golang: Printf

Tue, 15 Sep 2020 03:39:46 +0000

This is part 16 of my journey learning Golang.

The Printf method

The Printf method from the fmt package writes a formatted string to standard output.

Printf makes it possible to interpolate strings. This is done by leaving placeholders in a string, and using values to fill in these placeholders.

Printf syntax

Printf accepts a string argument, potentially with formatting placeholders, and zero or more value arguments. For example:

 1package main
 2
 3import (
 4  "fmt"
 5)
 6
 7func main() {
 8  answer := "C"
 9  fmt.Printf("Is %v your final answer?", answer)
10}

prints out:

Learning Golang: Println and Print

Sat, 12 Sep 2020 04:21:49 +0000

This is part 15 of my journey learning Golang.

fmt Package

Go’s fmt package implements formatted I/O with formatting functions in the venerable, old-school style of the C language, but modernized.

This article covers the most basic functions for printing out text Println and Print:

Println

The Println method prints outs a line of text to the standard output device.

It prints its arguments, with a space between them, and a new line character at the end.

Learning Golang: Assigning and printing variables

Fri, 11 Sep 2020 03:59:46 +0000

This is part 14 of my journey learning Golang.

As an exercise for Codecademy’s Learn Go course, I wrote my second Go program.

It simulates a catalog for a comic book store.

At this point the course has only covered the most fundamental parts of Go, like variables, simple data types, basic arithmetic, and printing. Arrays and functions are still out of the picture.

For that reason, the structure of the program is very primitive and there is a lot of repetition (room for improvement).

Learning Golang: Strings

Tue, 08 Sep 2020 01:35:40 +0000

This is part 13 of my journey learning Golang.

Strings in Go

Strings represent a sequence of bytes. More specifically, a read-only slice of uint8 integers.

Their main use is for representing text. This text is usually, but not necessarily, encoded as UTF-8. In Go, strings can also be used to represent text in any encoding, and also raw bytes, not necessarily corresponding to text.

It’s important to notice that strings can be empty (i.e. have a length of 0) and that they can be arbitrarily long (as large as it will fit in memory).

Learning Golang: Compilation Errors

Mon, 07 Sep 2020 21:06:17 +0000

This is part 12 of my journey learning Golang.

Compile-time errors

Go is a compiled language. That means that it will parse the source code and produce an executable binary file from it.

The compiler parses the code according to strictly defined rules. That allows Go programs to run more efficiently than if they were interpreted as they run.

As a valuable side-effect, it will reveal many kinds of errors (like typos or invalid code) immediately when the programs are compiled, as opposed to only when that particular part of the program is executed.

Learning Golang: Variables

Sun, 06 Sep 2020 18:13:20 +0000

This is part 11 of my journey learning Golang.

Variables

A variable is a named value that can change during the execution of a program. The difference from a constant (which is also a named value) is that a variable’s value can be modified at run time.

Variable declarations

In Go, variables are declared following this pattern: var {identifier} {type}. Examples:

1var songName string
2var lengthOfSong uint16
3var isMusicOver bool
4var songRating float32

Zero values

If a value is not assigned to the variable when it is declared (like above) then it is initialized with a “zero value”. The actual value depends on the data type. Generally:

Learning Golang: Literals and Constants

Sun, 06 Sep 2020 17:55:33 +0000

This is part 10 of my journey learning Golang.

Literals

In Go, values can be many things. Just to name a few, values can be numbers (like 109), or text wrapped in quotes (like “Hello world”).

Literals are values written in the source code. For example:

1fmt.Println("Hello, world!")       // String literal
2fmt.Println(42)                    // Integer literal
3fmt.Println(3.141592653589793238)  // Floating point literal

Constants

In addition to literal values (i.e. values directly expressed in the source code), Go also allows “named values”, i.e. values identified by a name. These named values are called “constants” because the value represented by the name remains the same throughout the runtime of the program.

Learning Golang: Basic data types

Wed, 26 Aug 2020 03:29:48 +0000

This is part 9 of my journey learning Golang.

Data types are a designation by a programming language about the kind of values that are being stored.

Go has several basic data types built in. This article explores boolean, numeric and string data types. See Go’s documentation for more details.

Boolean data type

Boolean values can be either false (equivalent to 0) or true (equivalent to 1). Although in principle they only require 1 bit of storage, Go uses a byte for convenience reasons.

Learning Golang: Running Go in a container

Sat, 22 Aug 2020 01:55:41 +0000

This is part 8 of my journey learning Golang.

Reproducible build & run environments

Over the years, it is not uncommon that different projects in the same language will have different requirements about the versions of the tools and libraries that they require.

For instance, I learned that there are differences in the behavior of the GO111MODULE environment variable across Go versions 1.12 and 1.13.

That’s why when I start a repository for a new project, one of the first things I do is to set up scripts for building and running the code in a reproducible way.

Learning Golang: Multiline strings

Fri, 21 Aug 2020 03:18:04 +0000

This is part 7 of my journey learning Golang.

My first assignment on Codecademy’s Learn Go course was to create a program that prints out ASCII art.

The way that’s different from a “Hello, World” program is that it needs to print multiple lines. So it was a great opportunity to learn about how multi-line strings can be represented in Go.

Go’s string literals

String literals represent “string constants” i.e. immutable string values in a Go source file.

Learning Golang: Resources for learning Go

Wed, 19 Aug 2020 03:27:35 +0000

This is part 6 of my journey learning Golang.

Books and tutorials

A Tour of Go: An introduction that covers the most important features of the language.
An Introduction to Programming in Go: A free e-book from 2012.
For the Love of Go: Fundamentals: An interactive introduction to the Go programming language, suitable for complete beginners.
Introducing Go: An O’Reilly book from 2016. “Perfect for beginners familiar with programming basics, this hands-on guide provides an easy introduction to Go.”

Chat

Go IRC Channel: Get live support at #go-nuts on irc.freenode.net, the official Go IRC
Gopher Slack: Get live support from other users in the Go slack channel.
Gophers Discord: Get live support and talk with other gophers on the Go Discord.

Forums

Go Forum: Discussion forum.
Go Nuts Mailing List: Discussion group.
golang sub-Reddit: A place for Go news and discussion.
StackOverflow: Community-driven questions and answers.
User groups: Local groups around the world.

Podcasts

Go Time Podcast: A panel of Go experts and special guests discussing the Go programming language, the community, and everything in between.

Tools

go doc: Command-line tool for displaying Go package documentation.

Websites

Awesome Go: An extensive, curated list of Go resources.
Frequently Asked Questions (FAQ): Answers to common questions about Go.
Go Wiki: A collection of information about the Go Programming Language.
GoDoc: Documentation for Go packages.
The Go Playground: A place to write, run, and share Go code.
The Go Programming Language: Go’s official website.

Takeaway

There is an abundance of resources for learning Go. Which ones would you recommend?

Learning Golang: Comments

Tue, 18 Aug 2020 04:02:00 +0000

This is part 5 of my journey learning Golang.

Inline comments

Go ignores text to the right of //:

1// This entire line is ignored by the compiler.
2// fmt.Println("Does NOT print")
3fmt.Println("This gets printed!") // This part gets ignored

Block comments

All lines between /* and */ will be ignored:

1/*
2This is ignored.
3This is also ignored.
4fmt.Println("This WON'T print!")
5*/

Godoc

Go has a tool for automatically generating documentation from Go source code: Godoc.

Learning Golang: Function declarations

Sun, 16 Aug 2020 17:31:12 +0000

This is part 4 of my journey learning Golang.

Function declarations

Functions are reusable blocks of code. For example:

1func main () {
2    fmt.Println("Hello, World!")
3}

The func keyword declares a function. It is followed by the function’s name, a list of arguments (delimited by parenthesis) and the function block (delimited by curly braces).

main function

In Go, the main function is special. When the main function is defined in the main package, it is automatically called when the program is executed.

Learning Golang: Packages

Sun, 16 Aug 2020 02:12:03 +0000

This is part 3 of my journey learning Golang.

Package declaration

The first line of a Go source file is the “package declaration”, defined by the package keyword.

This serves a few purposes:

It provides a structure for grouping related source files.
It provides a mechanism for code reuse.
It differentiates between executable packages from utility packages (i.e. libraries).

Example:

1package main

go build will produce an executable binary file for source files with package main.

Learning Golang: Compiling and running Go programs

Sun, 16 Aug 2020 01:55:20 +0000

This is part 2 of my journey learning Golang.

Compiling Go programs

An individual Go source file can be compiled with the go build command:

1go build {filename}.go

That will produce an executable binary file if the source’s package is main (see Part 3 for more on packages).

The resulting binary can be executed with this command:

1./{filename}

Example:

1$ go build main.go
2$ ./main
3Hello World

Running from source

The go run command combines the two previous steps: it builds a binary from a source file and executes it:

Learning Golang: Getting Started

Sun, 16 Aug 2020 01:30:03 +0000

This is part 1 of my journey learning Golang.

The Go programming language (Golang) is becoming more relevant by the day. It is, famously, the language of the Docker and Kubernetes projects. Both have had a huge impact on how companies run applications, and I develop for them on a daily basis. Golang is also seeing increased adotoption at my company.

I’m starting on a journey to become more familiar with this language. I decided to start from the fundamentals. I’m going to follow the Learn Go course on Codecademy