Forem: Guillaume Jacobs

The hype of frustration

Guillaume Jacobs — Tue, 13 Jun 2023 18:39:04 +0000

Recently, the engineering team behind Prime Video has announced moving away from their microservices and serverless architecture to a more monolithic approach. This news has sparked a lot of outcry on social media. Many are rejoicing and announcing the "death of the microservices era". Some are using this news to voice their growing frustration towards microservices and the ever increasing complexity in software development. So, could it really be the end of an era?

Microservices, and more largely, Service Oriented Architecture is not something recent. The idea of Service Oriented Architecture was to architect applications per business function rather than technical function. Instead of having a 3 factor application where your software would be divided into a User Interface layer, a business logic layer and a database layer, you would combine those layers together. The new boundary of your application would then be the business function of the application. This new architecture came with the freedom to build cross-functional teams that reduce knowledge silos and to reduce cross-team dependencies while building new features.

Posterior to that, a revolution rocked the IT industry. Cloud Computing started to become a mainstream thing. It offered cheap and accessible computing at the click of a finger with promises of infinite scalability and high availability. Anyone with little to no IT skills could now deploy their application to a Cloud platform in mere seconds for the world to see.

Microservices and Cloud were matches made in heaven. We could stretch the concept of Service Oriented Architecture to functionality bound, independently deployable artefacts thanks to the massive scalability capacities of the cloud platforms. Engineering teams could be scaled massively and work independently on their own services. Those services could then be deployed as independent units of compute without a need to align with other teams. Such promises brought a lot of hope in the industry, especially for companies that were stuck in an unmanageable amount of technical debt. But with the hope came the hype.

If there is one thing that social media excels at, it's creating the fear of missing out. Software development is no exception to the rule. Continuously, new hypes are emerging. Whether it is a new framework or tool, those media will let you think that you'll be left behind if you don't hop onto the train. Strong of some success stories, microservices became one of those hypes. For developers, it was the opportunity to work on bleeding edge technologies and be part of the change. For companies, it was the opportunity to solve their development bottlenecks, reduce their technical debt, and attract new talents. But many people forgot something fundamental along the way. Microservices and Service Oriented Architecture are just one archetype amongst many others. More importantly, in software architecture, there isn't a one fit-all solution, and this leads to two problems.

Firstly, some companies that didn't need microservices (or could have satisfied themselves with pseudo microservices) are spending countless engineering time and money in building a complex microservices architecture instead of focusing on their core businesses. I have personally worked in such companies were it was very unlikely to see a sudden burst in scalability or maintainability need. Yet, we spent months (and increasing AWS bills) building complex solutions that may or may not be needed one day, and that could have been a simple method call coupled with a rudimentary alerting mechanism at first.

This problematic can lead to some frustration on the business side because business needs can be delayed for the sake of planning for (potential) scalability needs, amongst other things. Some developers might also grow frustrated because they might rather spend their time on tangible work, like building new features, rather than more abstract work like designing fault tolerant and scalable microservices systems.

The second issue is that some companies that might need microservices pour all of their resources into a complete architecture and software refactoring, hoping to solve all of their problems at once. Unfortunately, such projects often end up failing. I've worked on such projects where a new GitHub organisation was created with hundreds of repositories at once. Those projects usually take years to achieve and involve countless of projects managers, POs, and hundreds of engineers. Managers who usually have the bigger picture in mind often come and go. Dependencies are often created during development, and tensions between teams are common. Engineers often work on very small and abstract pieces of software that can lead to a loss of work meaningfulness. Projects are very often and continuously delayed. Many times, the top management grows tired of the lack of results and pulls the plug. In the end, nobody is happy.

So, does it still make sense to use microservices? Shouldn't we find a simpler way of solving our SDLC and architecture bottlenecks? In my opinion, thinking that microservices are a mistake is as wrong as thinking that they should be used everywhere. The reality lies in between. I think that many companies don't need microservices, especially at the beginning. There is a critical mass under which microservices are overkill. Be it based on the amount of services, features, their complexities, number of lines of code, or amount of engineers working on the codebase should be left at the appreciation of experience and guts feeling. Most likely, it will be a conjunction of those factors anyway.

But they are cases where using microservices is an evidence. Many softwares are completely bloated and unmaintainable, and a modular architecture might not solve some specific problems. I've worked on old JEE monoliths made of millions of lines of code. Any code changes could break dozens of unit tests and have disastrous effects. Spinning up a dev environment can take up to half a day. Testing is even worse. In those cases, the advantages of using microservices are evident and immediate. Not only does it allow to improve maintainability and scalability, but it can also be coupled with a rewriting of the code that can help remove unnecessary complexities and, in many cases, dead code.

In those cases, and to avoid the pitfalls mentioned earlier, the best is to identify a piece of the code that could easily be decoupled. Thinking either in terms of domain or service is usually useful to make a map of your software and identify the parts that could be decoupled from your existing monolith. Do you have a video sharing software? A microservice that would be responsible for uploading videos to a storage exposed by a REST endpoint would be a good starting point. A dating app? A microservice that handles user profiles would be useful. What matters the most is that you start small and that you keep it stupid simple. You won't need distributed tracing and complex queuing mechanisms for the near future. Start small, reap the benefits, and iterate. With microservices, the benefits lie as much in the journey as in the destination.

Go 101: Variables, Constants and Scopes

Guillaume Jacobs — Tue, 15 Nov 2022 15:08:20 +0000

In programming, variables are placeholders holding values. A variable in Go is associated with four elements: a keyword, a name, a type and a value. Variables are particularly useful to hold values we might want to use throughout our program, and to avoid using literal values everywhere.

Asides from variables, Go offers the possibility to use constants. Constants also have the ability to hold values. However, the value associated to a constant cannot be changed once it has been assigned, as opposed to variables.

In this tutorial, we will also go through the concept of scope. A scope defines the boundaries within which our variables and constants can be accessed. We are going to see that Go is characterised by a lexical scope, defined within curly brackets. Go is also characterised by a package scope, a feature that we will study in a later tutorial when we speak about functions.

Variables

As mentioned in the introduction, a variable is characterised by four elements: a keyword, a name, a type and a value.

In Go, a variable definition starts with the var keyword.

Following the var keyword, a name for this variable must be chosen. In Go, there is an idiomatic set of rules that should be followed in order to correctly name a variable. Names should always start with a letter. The subsequent characters can either be other letters, numbers or underscore. In addition, the naming convention dictates the usage of camel case for compound names (eg. minNumber).

As Go is a statically-typed language, each variable needs to be assigned a data type, and that type cannot be changed throughout the lifetime of this variable. Those types can be any of those we have seen so far (string, number, boolean), or any other more complex types we will see later on.

Finally, our variable needs to be assigned a value. This value can be a literal value (for example, 1 or "Hello, World!"), but any another variable or constant can be assigned as a value too. The value assignment is independent from the variable declaration (where we define the keyword, the name and the type). Therefore, this last step can actually be performed later on in the program, after the variable declaration.

Programmatically, a variable is defined as followed.

var hello string = "Hello, variable!"

As you can see, we have used our var keyword, the name of our variable is hello, the type of our variable is a string and the value is "Hello, variable!".

As mentioned earlier, we could have divided the declaration and the value assignment into two separated lines.

var hello string
hello = "Hello, variable!" 
/* We use the name of our variable to assign a value to it, using the = sign */

As the name suggests, we can change the value assigned to our variable at any point in our program (but not its type). To do so, we just need to reassign a value to that variable.

var x string = "Original value"
x = "Substituted value"
fmt.Println(x)
// This will print "Substituted value" to the console

If we run this program, it will output "Substituted value" to the console. It is indeed the value we have reassigned to our variable x in the second line of our program.

In fact, there are shorter ways we can use to define a variable. As a convention, those shorter versions should be used whenever it is possible.

Firstly, we could remove the type from our declaration. Go’s compiler is indeed capable of inferring the type of a variable by looking at the value being assigned. This however only works if we declare and assign a value to our variable in the same line. The program wouldn’t compile otherwise.

var hello = "Hello, variable!" 
// Go will infer that our variable is of type string

There is a way to shorten our declaration even more, by removing the keyword var. To do so, we also need to change the assignment operator from = to :=. Again, we can only use this method if we declare and assign a value to our variable in the same line.

hello := "Hello, variable!"

This method is much shorter than the previous ones, and is considered idiomatic. Therefore, you should use it whenever it is possible.

Constants

Similarly to variables, constants are made of four elements: a keyword, a name, a type and a value. As the name suggests, once we have assigned a value to a constant, no value can be reassigned to that constant. It makes constants very useful to hold stable values throughout the execution of your program, such as mathematical constants.

To define a constant, you will need to use the const keyword.

const pi float64 = 3.1416

As the value of a constant cannot change, reassigning this pi constant would produce a compiling error.

Similarly to variables, it exists a shorthanded version for declaring a constant. You can do so by removing the type from the declaration.

const pi = 3.1416

It is however impossible to remove the const keyword from the declaration. Go would indeed assume that we are trying to define a variable instead of a constant.

Multiple definitions

Similarly to other programming languages, it is possible in Go to define multiple variables (or constants) at the same time.

var (
     first = "I"
     second = "love"
     third = "Go."
)

It is important to notice several things here. Firstly, each variable (or constant) should be on its own line. Secondly, we voluntarily omitted the type (it would be totally valid to declare it). Lastly, as we use the keyword var (const for constants), we use the = assignment operator (and not the := operator).

Scopes

In programming, a scope defines the boundaries within which we can access a variable (or constant).

Without scopes, one major issue could arise in our programs. This issue is known as naming conflict. Those conflicts arise when we are trying to declare a variable with a name that is already used somewhere else in our program by another variable. Unknowingly, we would then reassign the value of the first variable. This can lead to awkward and hard to track bugs.

To avoid those issues, Go is using what we call a lexical (or static) scope. In other words, the possibility to access a variable (or constant) depends on the location where this variable is declared in the first place. This lexical scope is the opposite of a dynamic scope where we can access variables declared in other functions, as long as those functions are located below in the stack.

In Go, this lexical scope is restricted by a block. This block itself is bounded by curly braces. In other words, a variable (or constant) can only be accessed within the block in which it is defined. For example, a variable defined inside of a function would only be accessible inside this function, and not outside of it.

This lexical rule also includes any child scope within the boundaries of the scope. For example, we could access the variables defined in a function from a conditional block, if this conditional block is located inside that function (the conditional block being the child scope).

It is also worth mentioning that a variable (or constant), declared in the global scope (outside of any function or condition blocks), will be accessible everywhere in our program. The global scope is indeed the parent scope of all the other scopes defined in our program. It is however advised to use this global scope with caution, as using it could lead to naming conflicts in our programs.

It is also important to note that any variable or constant declared in the global scope should be declared with a keyword (const or var). Failing to do so will lead to a compiler error.

In order to illustrate this concept of scope, let’s create the following two programs.

In this program, we define two functions. The first function, main, will access our variable x defined in the global scope as well as calling our second function. This second function, testScope, accesses the same global variable, and print it to the console too (with a "test" string concatenated).

In this program, we define the variable x inside the main function. We also call the testScope function from our main function. TestScope tries to print x to the console as well. However, writing the program in such a way will provoke a compiling error, as x is unaccessible from the testScope function. Indeed, x is defined inside the block of the main function, and can only be accessed inside that same block.

Conclusion

In this tutorial, we have continued our journey through the basic concepts of Go. We have explored the concepts of variables, constants and scopes. Mastering those concepts is fundamental in order to continue our journey, and explore the advanced parts of the Go language. In our next tutorial, we will explore control structures in Go.

Go 101: Basic Types

Guillaume Jacobs — Tue, 08 Nov 2022 15:00:57 +0000

Programming languages are made of fundamental concepts, shared by many of those languages, if not all of them. One of those core elements is the concept of data type.

It is quite complicated to give a satisfying definition of what a data type is. A functional definition of a data type would be to define it as a set of items having similar properties (eg. they are numbers). On this set, we can apply an homogenous and defined set of actions (eg. accessing a part of an item via an index). Furthermore, the items in this set are stored in the computer in a similar way.

In this tutorial, we are going to cover the different categories of basic data types in Go, what kind of actions we can perform on them, and how they are stored in our computer.

If you are new to Go, and have missed the first part of this tutorial, feel free to go and check it by clicking on this link. If you have already followed along the first tutorial, I recommend you to create a new directory called types inside your src directory. Inside of this newly created directory, create a new main.go file, where you will be able to write today's code.

Numbers

Our first category of data types are numbers. Unsurprisingly, all the data types inside this category have in common that they represent numbers. Similarly to most programming languages, we can subdivide Go's numbers types into two main sub-categories: integers and floating-points.

Integers

Most of you should already know what an integer is. Integers are part of the set of whole numbers (meaning that they don't have decimal places). Those integers hold values that can be negative, positive or equal to zero. Examples of integers are as follow: -25, 0, 17, 2020, …

If you work with integers in Go, you will most likely only use the int data type (signed integer). This is the classical 32 or 64-bits wide integer (depending on your machine) that you would see in most programming languages. There are other integer types in Go, including int8, int16, int32 or int64. Each of them uses a different amount of bits, but they are fundamentally the same.

Go also has a uint type (unsigned integer). This type can only hold positive values, or zero. Similarly to the signed integers, Go also has built-in uint8, uint16, uint32 and uint64 types.

Finally, and mostly as a reference for you, Go also has a built-in uintptr type. This type is used for creating integer representation of a memory address. You will most likely never use this type, unless you are adventuring yourself into the realm of advanced pointers logic.

Floating-points

As opposed to integers, floating-points numbers are numbers with a decimal component. 3.14, 2022.11, -123.5 or 5.0 are all floating-points.

There are two floating-points types in Go: float32 (also called single precision float) and float64 (double precision float). Those two types respectively use 32 or 64 bits.

By default, you should stick with float64 as it offers more precision (unless you are in a memory-constrained environment). Indeed, and as opposed to integers, floating-points are inexact numbers.

In the following example, we are going to demonstrate this point.

You would expect that 1.51 – 1.50 would result into 0.01. However, running this program gives an other result. The fmt.Println(1.51–1.50 == 0.01) will print to the console a boolean. If, 1.51 – 1.50 was indeed equals to 0.01, you should see true being printed to your console. However, after running this program, we see the value false being printed to the console.

This result shows that floating-points are indeed non-exact numbers and you should be very careful when performing conditional logic involving floats.

Similarly to uintptr with int, complex64 and complex128 are two other floating types built respectively on top of the float32 and float64 types. Those types deal with complex numbers arithmetic and you will probably not use them.

Operations with numbers

Go supports basic arithmetic operations to be performed on numbers. Those operations include:

Addition, using the symbol +

fmt.Println(1 + 1)
// Print 2 to the console (this is also a comment in Go)

Subtraction, using the symbol -

fmt.Println(1 - 1)
// This would print 0 to the console

Multiplication, using the symbol *

fmt.Println(2 * 2)
// This would print 4 to the console

Division, using the symbol /

fmt.Println(2 / 2)
// This would print 1 to the console

Remainder of a division, using the symbol %

fmt.Println(3 % 2)
/* This would print 1 to the console. 
Also, this is a multi-line comment in Go */

Strings

In our "Hello, World!" tutorial, we have already seen what a string is. It is any sequence of characters that is placed in between double quotes. Strings can also be defined within backticks. Defining a string with backticks can be useful if you want to create multi-lines string literals.

It is important to note that single quotes are only used to define what is called a rune, another built-in data type that represents a single character. If you come from a language like Python or JavaScript, it is therefore very important to always use double quotes (or backticks) in Go instead of single quotes when defining a string literal.

One of the main property of a string is its length. This length is defined by the number of characters that a string possesses. The length starts from zero (an empty string), and can go to any integer above.

Usually, but it is not always true (eg. Chinese character), each element of a string is stored as a single byte.

Operation with strings

There is a series of basic operations that we can perform with strings.

Calculate the length of a string with the len built-in function.

fmt.Println(len(""))
// This would print 0, as it is an empty string
fmt.Println(len(" "))
// This would print 1, as a space is considered a character
fmt.Println(len("Go is an amazing language"))
// This would print 25

Accessing a particular element (character) of the string with the [i] notation placed after our string, where i is the index (integer) of the element we want to access (i = 0 being the first element of the string).

fmt.Println("Learning Go is a good investment"[1])
// This would print 101 to your console

Again, if you come from a language like Python or JavaScript, you would have expected to see the character ‘e’ (the second element of our string) being printed to the console. Indeed, Go doesn’t print the actual character when we try to access it, but the ASCII value representing this specific character. In this specific case, the character 'e' is represented by the ASCII value of 101.

Concatenate two, or more, different strings together, using the + symbol.

fmt.Println("Hello, " + "World!")
// This will print Hello, World! to the console

Booleans

The last basic type in Go is the boolean type. This type is used for representing true or false logical values in our programs, and more generally to perform conditional logic. In the computer, those values are stored as a one bit integer, respectively 1 and 0.

The boolean values are heavily used when performing conditional logic in our programs. We have already seen one example of a boolean earlier, when we demonstrated that floating-point numbers are inexact.

Conditional operators

Booleans are often used in combination with conditional operators in order to represent more complex logic in your programs. Go has three built-in conditional operators.

&& : This represents the logical And operator. A conditional logic using the And operator will evaluate to true if the elements on both sides of the operator are true or evaluate to true.

fmt.Println(true && true)
// This returns true
fmt.Println(true && false)
// This returns false
fmt.Println(false && true)
// This returns false
fmt.Println(false && false)
// This returns false

|| : This represents the logical Or operator. A conditional logic using the Or operator will evaluate to true if at least one of the elements on one side of the operator is true or evaluates to true.

fmt.Println(true || true)
// This returns true
fmt.Println(true || false)
// This returns true
fmt.Println(false || true)
// This returns true
fmt.Println(false || false)
// This returns false

! : This represents the logical Not operator. A conditional logic using a logical Not operator will evaluate to true if the value after the operator is false or evaluates to false. On the other hand, the conditional logic will evaluate to false if the value after the operator is true or evaluates to true.

fmt.Println(!true)
// This returns false
fmt.Println(!false)
// This returns true

Playing around with types

If you would like to play around with types more, there is an interesting built-in package that you can use in your program. This package is called reflect. In this package, you can make use of the TypeOf function. You can pass any value to this function and it will return the type of that value.

It can be interesting for example to experiment with edge cases, and check the resulting type with the TypeOf function. One of those cases could be to check what happens if you add a float to an int.

In today’s tutorial, we have covered the three basic categories of data types in Go. Most of the other built-in types in Go are actually built on top of those basic types.

Below, you can find a gist with all the code we have been writing in this tutorial. I really encourage you to run the program yourself, and play around with it to test different things. Getting familiar with the basics of Go is very important for the rest of our journey.

In the next tutorial, we will cover the concepts of variable, constant and scope in Go. I am looking forward to it and I hope you will enjoy it!

Go 101: Hello, World!

Guillaume Jacobs — Mon, 31 Oct 2022 16:14:58 +0000

Go, or Golang, is a programming language pioneered by three Google employees: Robert Griesemer, Robert Pike, and Kenneth Thompson. Firstly announced in 2009, version 1.0 of the language was released to the public in early 2012. The two main goals of the creators were to create a language that enforces software engineering’s good practices as well as making the process of working on large systems more productive and scalable.

Go is a fairly easy language to learn, yet is very powerful. This feature has helped Go progressively replacing C in some area while conserving C's best features. Indeed, Go is a statically typed language (which helps create safer and better-designed programs) as well as a compiled language (which improves run-time efficiency).

The team behind Go has been working hard on trying to make it as user friendly as possible in the past years by packaging countless tools with the Go compiler. Furthermore, Go is an open source project, with a huge support from the community and has an enormous amount of tools and libraries available to facilitate the development of Go programs.

Thanks to this, in the past years, Go has been continuously voted one of the most-loved programming languages in different indexes and surveys, including Stack Overflow annual surveys.

Two of the most famous modern software tools out there, Docker and Kubernetes, have been built with Go. Many companies, such as Google, IBM, and Uber, have also migrated part of their production services to Go.

For all of those reasons, Go is really worth learning. It will become more and more relevant over the years to come, especially in the microservices and DevOps area where it has seen an outstanding growth.

Prerequisites and basic concepts

In order to write your first program in Go, you will firstly need to fulfil some prerequisites.

The first one, quite obviously, is to install Go’s toolset. You can do so by navigating to the Go download page and installing the latest stable release of Go for your operating system.

Secondly, and this part is specifically for those of you without any programming experience, you will need to install a code editor as well as setting up your terminal. The code editor is the place where you will write your code. As a personal preference, I really recommend Visual Studio Code, which is fairly easy to use and also offers support for Go via plugins (auto-formatting, autocompletion, and more).

On the other hand, the terminal is the place where you will run commands (in order to build or run your code, navigate through your projects, etc...). Opening your terminal is dependent on which operating system you are using:

Windows: The terminal, or command prompt, is accessed by pressing the Windows key + R. You should then type “cmd.exe” and hit Enter.
Mac: The terminal can be accessed by opening your Finder, then by clicking on Applications, followed by Utilities. From there, you can start the terminal application.

To verify that the previous steps have been successful, you can write the following command in your terminal

go version

If you have followed along correctly, you should see an output on your terminal telling you which version of Go you are currently using, similarly to the following snippet.

go version go1.18 darwin/amd64

It is possible, for various reasons, that you might get an error while trying to run the previous command. If so, please refer to the comments section of this post and we will try to solve your issue. You can also, as a good practice, google your issue and find a solution on websites like Stack Overflow.

The most common issues are when you download the Go toolset for a different OS architecture than yours, or when the Go binary is not properly located in your executable path. It can be the case if you are using zsh instead of a Bash shell with a Mac (the error being go command not found). In that specific case, you have to add the path to the go executable to your .zshrc file located in your home directory. Add the following line, save, and the go command should now be available.

export PATH=$PATH:/usr/local/go/bin

The last thing that you need in order to build your first Go program is an understanding of the gopath. The gopath is an environment variable that tells Go where to look for source code, compiled packages, or executable binaries on your computer. By default, the gopath is located in your user’s home folder and doesn't need any extra configuration (Users/YourName/go for Mac and Linux, c:\Users\YourName\go for Windows).

This go directory should be subdivided into three sub-directories, namely src, bin and pkg. In order to create those sub-directories (if they weren't created by default or if you chose a different location), you should use your terminal and run the following commands inside your home directory:

On Windows:

md go
cd go
md src bin pkg

On Mac or Linux

mkdir go
cd go 
mkdir src bin pkg

The src subdirectory is the most important one for the moment, as it is the one where our source code will live. The two other subdirectories will store compiled packages as well as executable binaries.

"Hello, World!"

In order to build our first program, we firstly need to create a new directory inside the src directory, and create an empty go file inside of it. For the sake of our tutorial, let’s call our new directory hello and our file main.go. To do so, let’s run the following commands in our terminal. Depending on your OS:

On Windows

md src\hello
cd src\hello
copy nul main.go

On Mac or Linux

mkdir src/hello
cd src/hello
touch main.go

Those commands will create the hello directory, allow you to navigate into that same directory, and finally create an empty file named main, with a go file extension (telling Go’s toolset that what is inside this file is code written in Go).

From there, you need to open the newly created file with your text editor of choice. If you are using VS Code, and you have installed the code command using the command palette, you can simply run the following command from your terminal.

code .

This will open the current working directory directly into VS Code. If you haven't made those configuration, you can directly open the hello directory from VS Code.

Once you have opened the main.go file with your code editor, you should write the following code and save it. Beware that the indentation and position of the brackets are very important for the program to compile.

Let’s now go over each line of code and explain what is happening, step by step.

package main: This is known as a package declaration. Each Go program starts with a package declaration. The reason is to encourage better software design and code reusability. In order to run a program in Go, you must define a package named "main". It doesn’t matter what our file is called (we could have called it hello.go). What is important is that the compiler needs to find this package main line to produce an executable file successfully (any other package name would be considered as a library). It is important to note that every file within the same directory should have the same package name.
import "fmt": The import keyword is used to import source code from another package. In this case, we import a package called “fmt” (shorthand for formatting). This built-in package with Go language is used to format inputs and outputs (we will use it mainly to print outputs to the terminal while running our programs). We can, of course, import multiple packages inside the same file.
func main() { }: This is called a function declaration. A function must start with the keyword func. This keyword is followed by the name of the function (in this case, main). Between the parentheses, we can define a series of parameters. For example, we could imagine a function that would sum up two numbers. Our function would then have two parameters, a and b, our two numbers. Between the curly braces is the body of the function. This is where we define what our function actually does. Every main package should have one function called main. This is indeed the entry point to our program. Without this main function, our program wouldn’t compile. It is also important to mention that this main function cannot take any argument nor return any value (as opposed to C).
fmt.Println("Hello, World!"): This is the only line of the body of our function. In this line, we access the Println function defined in the fmt package. To this function, we pass the following argument: “Hello, World!”. This argument is known as a string. A string, in Go, characterises any set of characters defined between double quotes. This Println function is therefore invoked in our main function, which provokes our terminal to output the following line once the program runs.

Hello, World!

Running the Program

As said earlier, Go is a compiled language. Thus, our program firstly needs to be compiled into machine code in order to be run. To do so, there are two options that we can use in our terminal.

Firstly, we can compile our program with the following command:

go build main.go

Once the program is compiled, we can then directly run the newly created binary executable, using the following command:

On Windows

main

On Mac or Linux

./main

This entire workflow can also be accomplished using a single command:

go run main.go

The latest command actually does two things behind the scene. It firstly runs the go build command, and then executes the freshly created binary. All of this happen within a temporary directory, which is then deleted once the program is done executing.

While the go run command is useful in a development setup or for scripting purposes, the persistent binary file created by go build should be privileged in a production setup, especially for performance reasons.

Goodbye, World!

Congratulations! If you have followed along this tutorial, you should have managed to run your first Go program. If anything went wrong along the way, feel free to reach out to me in the comments and I will help you troubleshoot your issue.

In this tutorial, we have covered the very basics of Go, from setting up your local environment to running your first program. In the next tutorials, we will cover in details the different main features of Go, including its data types, control flow, and functions, amongst many other aspects of the language. I am looking forward to it, and I hope you will enjoy the journey!