Go is a modern, generic-purpose, open source programming language that was officially announced at the end of 2009. Go began as an internal Google project, which means that it was started as an experiment, and has since been inspired by many other programming languages, including C, Pascal, Alef, and Oberon. Go's spiritual fathers are the professional programmers Robert Griesemer, Ken Thomson, and Rob Pike.

They designed Go as a language for professional programmers who want to build reliable, robust, and efficient software. Apart from its syntax and its standard functions, Go comes with a pretty rich standard library.

At the time of writing, the latest stable Go version is version 1.13. However, even if your version number is higher, the contents of the book will still be relevant.

If you are going to install Go for the first time, you can start by visiting https://golang.org/dl/. However, there is a big chance that your UNIX variant has a ready-to-install package for the Go programming language, so you might want to get Go by using your favorite package manager.

The Go community is already discussing the next major version of Go, which is going to be called Go 2, but there is nothing definitive at the moment.

The intention of the current Go 1 team is to make Go 2 more community driven. Although this is a good idea in general, it is always dangerous when lots of people try to make important decisions about a programming language that was initially designed and developed as an internal project by a small group of great people.

Some of the big changes that are being considered for Go 2 are generics, package versioning, and improved error handling. All these new features are under discussion at the moment and you should not be worried about them, but it is worthwhile to have an idea of the direction that Go is going in.

Go has many advantages, and some of them are unique to Go, while others are shared with other programming languages.

The list of the most significant Go advantages and features includes the following:

• Go is a modern programming language that is easy to read, easy to understand, and was made by experienced developers.
• Go wants happy developers because happy developers write better code!
• The Go compiler prints practical warning and error messages that help you to solve the actual problem. Putting it simply, the Go compiler is there to help you, not to make your life miserable by printing pointless output!
• Go code is portable, especially among UNIX machines.
• Go has support for procedural, concurrent, and distributed programming.
• Go supports garbage collection, so you do not have to deal with memory allocation and deallocation.
• Go does not have a preprocessor and does high-speed compilation. As a consequence, Go can also be used as a scripting language.
• Go can build web applications and provides a simple web server for testing purposes.
• The standard Go library offers many packages that simplify the work of the developer. Additionally, the functions found in the standard Go library are tested and debugged in advance by the people who develop Go, which means that, most of the time, they come without bugs.
• Go uses static linking by default, which means that the binary files produced can be easily transferred to other machines with the same OS. As a consequence, once a Go program is compiled successfully and an executable file is generated, you do not need to worry about libraries, dependencies, and different library versions anymore.
• You will not need a graphical user interface (GUI) for developing, debugging, and testing Go applications, as Go can be used from the command-line, which I think many UNIX people prefer.
• Go supports Unicode, which means that you do not need any extra code for printing characters from multiple human languages.
• Go keeps concepts orthogonal because a few orthogonal features work better than many overlapping ones.

There is no such thing as the perfect programming language, and Go is not an exception to this rule. However, some programming languages are better at some areas of programming or we like them more than other programming languages. Personally, I do not like Java, and while I used to like C++, I do not like it anymore. C++ has become too complex as a programming language, whereas, in my opinion, Java, code does not look good.

Some of the disadvantages of Go are:

• Go does not have direct support for object-oriented programming, which can be a problem for programmers who are used to writing code in an object-oriented manner. Nevertheless, you can use composition in Go to mimic inheritance.
• For some people, Go will never replace C.
• C is still faster than any other programming language for systems programming and this is mainly because UNIX is written in C.

Nevertheless, Go is a pretty decent programming language that will not disappoint you if you find the time to learn it and program in it.

I said earlier that Go does not have a preprocessor and that this is a good thing. A preprocessor is a program that processes your input data and generates output that will be used as the input to another program. In the context of programming languages, the input of a preprocessor is source code that will be processed by the preprocessor before being given as input to the compiler of the programming language.

The biggest disadvantage of a preprocessor is that it knows nothing about the underlying language or its syntax! This means that when a preprocessor is used, you cannot be certain that the final version of your code will do what you really want because the preprocessor might alter the logic as well as the semantics of your original code.

The list of programming languages with a preprocessor includes C, C++, Ada, and PL/SQL. The infamous C preprocessor processes lines that begin with # and are called directives or pragmas. As stated before, directives and pragmas are not part of the C programming language!

The Go distribution comes with a plethora of tools that can make your life as a programmer easier. One of these tools is the godoc utility, which allows you to see the documentation of existing Go functions and packages without needing an internet connection.

The godoc utility can be executed either as a normal command-line application that displays its output on a terminal, or as a command-line application that starts a web server. In the latter case, you will need a web browser to look at the Go documentation.

The first way is similar to using the man(1) command, but for Go functions and packages. So, in order to find information about the Printf() function of the fmt package, you should execute the following command:

$ go doc fmt.Printf
  

Similarly, you can find information about the entire fmt package by running the following command:

$ go doc fmt
  

The second way requires executing godoc with the -http parameter:

$ godoc -http=:8001
  

The numeric value in the preceding command, which in this case is 8001, is the port number the HTTP server will listen to. You can choose any port number that is available provided that you have the right privileges. However, note that port numbers 0-1023 are restricted and can only be used by the root user, so it is better to avoid choosing one of those and pick something else, provided that it is not already in use by a different process.

You can omit the equal sign in the presented command and put a space character in its place. So, the following command is completely equivalent to the previous one:

$ godoc -http :8001
  

After that, you should point your web browser to the http://localhost:8001/pkg/ URL in order to get the list of available Go packages and browse their documentation.

In this section, you will learn how to compile Go code. The good news is that you can compile your Go code from the command line without the need for a graphical application. Furthermore, Go does not care about the name of the source file of an autonomous program as long as the package name is main and there is a single main() function in it. This is because the main() function is where the program execution begins. As a result, you cannot have multiple main() functions in the files of a single project.

We will start our first Go program compilation with a program named aSourceFile.go that contains the following Go code:

package main 
  
import ( 
    "fmt" 
) 
 
func main() { 
    fmt.Println("This is a sample Go program!") 
} 

Notice that the Go community prefers to name the Go source file source_file.go instead of aSourceFile.go. Whatever you choose, be consistent.

In order to compile aSourceFile.go and create a statically linked executable file, you will need to execute the following command:

$ go build aSourceFile.go
  

After that, you will have a new executable file named aSourceFile that you will need to execute:

$ file aSourceFile
aSourceFile: Mach-O 64-bit executable x86_64
$ ls -l aSourceFile
-rwxr-xr-x  1 mtsouk  staff  2007576 Jan 10 21:10 aSourceFile
$ ./aSourceFile
This is a sample Go program!
  

The main reason why the file size of aSourceFile is that big is because it is statically linked, which means that it does not require any external libraries to run.

There is another way to execute your Go code that does not create any permanent executable files – it just generates some intermediate files that are automatically deleted afterward.

So, in order to run aSourceFile.go without creating an executable file, you will need to execute the following command:

$ go run aSourceFile.go
This is a sample Go program!
  

As you can see, the output of the preceding command is exactly the same as before.

This book mainly uses go run to execute the example code; primarily because it is simpler than running go build and then executing the executable file. Additionally, go run does not leave any files on your hard disk after the program has finished its execution.