In order to get started with this course we're going to need a couple of things installed and set up on our system. Through this lesson we're going to go ahead and set up our environment so that we're able to write, compile and run Go code on our system which is going to be important through this course. And throughout the rest of the lessons in this module we'll be doing a brief overlook at some of the features when it comes to Go in order to establish a good baseline. If you already happen to know how to use Go and you want to get started in the actual course content then I would recommend starting from module 1 which is where we're going to start building a command line application from scratch which we'll be developing upon throughout the first half of this course.

With that out of the way let's talk about actually setting up Go on our system. In order to do so the first thing I would recommend is starting on the go.dev website which is where you can find downloads in order to install Go onto your system. If you click the download link it should provide you a list of all of the different versions of Go that you can install. The latest version at the time of recording this video is Go 1.24. However throughout this course I'm using Go 1.23. This is because most of the course was filmed before 1.24 was released but it shouldn't make too much difference to the actual content of the course as both versions are pretty similar in themselves and there's no real breaking changes. Additionally Go has some fantastic backwards compatibility so again it should work without any issue. However feel free to use 1.24 or 1.23 if you like. 1.24 should work with every lesson in this course due in part to Go's fantastic backwards compatibility. Additionally there's no breaking changes that have come to 1.24 that 1.23 can't work with.

The easiest way to install Go is to click the get started button and you should be presented with a page that will allow you to install the latest version of Go for your operating system. Throughout this course I'm going to be using Linux for my operating system specifically Nix OS although there will be some points when I show using Arch Linux as well. If you happen to be using a Linux system yourself I recommend installing Go through your package manager so if you're on Nix that would be using the Nix package manager or if you happen to be on Arch you can install it using Pacman as follows.

If you happen to be using Mac OS you can either install it through the install link or if you happen to have the homebrew package manager installed you can install it using the following:

brew install go

If you happen to be on Windows whilst you can install Go through the Microsoft Windows installer I actually recommend using the Windows subsystem for Linux throughout this course. This is because we'll mainly be focused on Unix-like systems when it comes to writing Go code and whilst most of the code should work for Windows systems there are going to be a couple of situations where it's going to be mainly focused around Unix. These are things related to file permissions, file locking and also displaying a dialogue in a later lesson.

In any case once you've managed to get Go installed you can then go ahead and run the following command inside of your terminal:

go version

This should print out a similar string to what I have on screen which will let you know the version of Go that you're currently running as well as the operating system and architecture strings. Once you have Go installed the next thing you're going to want to set up is a text editor. Preferably one that has a language server protocol and will provide good syntax highlighting and auto-completion. Throughout this course I'm going to be using my terminal and NeoVim which is my work environment. However if you're just getting started to software development I wouldn't recommend taking this approach as it's a much more advanced text editor and work environment and instead relies on you knowing keyboard shortcuts and bindings in order to navigate around your system.

Throughout this course I'll mostly be using a keyboard although I will use my mouse to highlight certain sections when I think they're relevant to show. If you are getting started I would recommend a text editor such as Visual Studio Code which is available on macOS, Linux and Windows and will provide some and provides all of the features that I mentioned out of the box. Additionally you could also consider using Goland by JetBrains which also provides all of the same functionality that I mentioned. One thing to consider with JetBrains however is that I don't believe it comes for free. So I still recommend using VS Code if you're a beginner to software development and have never used a text editor before.

If you are more familiar with the terminal and the command line and want to use a terminal based editor such as NeoVim and you want to use NeoVim like I do you can find a link to my .files in the lesson description down below. You can find it inside of .config/nvim and if you just take this directory you'll have the same setup that I do. Be advised my setup does need some TLC and there's not really any documentation related to it so if you do use it then you may expect some bugs or some weird behaviour. If you want to use NeoVim and you don't want to use my setup I recommend checking out LazyVim which is a very powerful pre-rolled NeoVim configuration that can get you set up and running pretty quickly. It's also incredibly easy to install. So I definitely recommend it over using my own personal one at this stage.

In any case once you have both Go installed and your text editor set up the next thing to go and do is to make sure that you're able to run and deploy your code easily. To do so we're going to do a quick hello world and in the next lesson we'll take a look at some very basic Go concepts that we'll be using throughout this course although we will be teaching more as we go through it. To write our hello world I recommend starting inside of the terminal if you can. You can open this up in your terminal application if you're on Mac or Linux or the WSL terminal if you happen to be running on Windows. Once inside you should be inside of your home directory which if you type in the following command:

pwd

You can see I'm in /home/elliot which is my user's home folder. In order to create our hello world let's do it inside of a dedicated folder. For myself I like to keep all of my code inside of a directory called projects which is how I like to organize and structure my system. Inside of this directory go ahead and create a new directory using the make directory command which is mkdir. This will create a new directory or a folder inside of the directory that we're already in if we specify a relative path or we can use it to create an absolute directory as well. In any case here let's go ahead and create a new folder called hello world as follows:

mkdir hello-world

Then we can use the cd command which allows you to change into that directory. cd stands for change directory and we can go ahead and change into the hello world directory or folder:

cd hello-world

If I use pwd command which stands for print working directory you can see I'm now in /home/elliot which is my home folder /projects which is where I keep my code and /hello-world. Additionally you can also create this folder inside of your explorer if you want to but I recommend getting used to the terminal as we're going to be using it a lot throughout this course.

Once you're inside of your terminal the next thing to do is to go ahead and create a new file. When it comes to a Unix terminal there are many different ways to do this. You can use the touch command followed by the name of the file which would just create a new file inside of your directory. For example if I go ahead and do this:

touch main.go

You can see now inside of my directory I have an empty file which if I do ls -l you can see it has zero bytes—a completely empty file called main.go inside of my directory. Before showing another way of creating a file using a text editor I'm first going to go ahead and delete the main.go file by using the rm command which will delete the file from my system. By the way the rm command doesn't move files into a trash instead it just fully deletes them from the system so be careful when using it and prefer to use something like your system's trash rather than using the rm command it's a very dangerous command to get wrong.

In any case the other way to create a directory if you're using NeoVim or VS Code. If you're using VS Code you should have the code command which will open up your editor for you and you can create your file inside. If you're using NeoVim or a terminal based editor however you can use the nvim command and pass in the name of the file that you wish to create in this case main.go.

nvim main.go

Now my editor has opened up the main.go file but it hasn't yet created it not until I save this file but if I go ahead and save it which in NeoVim is done using :w, the file has now been created as you can see at the bottom of my screen. Depending on your editor or your situation go ahead and create a new file called main.go in the directory we just created and we're going to go ahead and print out hello world which is the customary starting point when it comes to learning a new language.

To begin, first add in the following line at the top of your file called package main. When it comes to Go every .go file must belong to a package and all of the files in the same directory must belong to the same package. For example if I had another file inside of this directory called print.go then this file would also need to be part of the main package as well. If I try to name it to another package of which you can specify nearly any arbitrary name when it comes to a package provided it doesn't have any symbols provided it starts with a letter so you couldn't do package 12 you would need to start the letter as foo say.

As you can see my editor is now complaining that we have a package name of foo and we expected the package main. Of course we could just go ahead and change our main.go to have the package name of foo and then the print.go won't complain about the package naming conflict anymore. However there is a specific reason why we're calling our package main. This is because when it comes to Go if you want your code to run as an application then you must have at least one main package inside. This allows you to use say the go run or go build commands in order to turn your code into an application or to make it executable. If we had the package name of foo then we would no longer have a main package and our code would act as if it was a library or a module rather than acting as an application. Therefore because we want our code to be executable we need to define a main package of which every application has to have one. Let's also go ahead and get rid of the print.go file as we no longer need it.

As well as defining a main package every application also has to have a main function. Both the main package and the main function together act as the entry point for the operating system when it executes your code and so forth and therefore because we want our code to be executable and to act as an application then it needs to have a main function inside of the main package. With that we have the basic requirements for our application. We have our main package and we have our main function. We're going to be seeing this a lot throughout the course so it's a good thing to know at this stage.

Next we then want to go ahead and print out the words "hello world" to the console. In order to do so in Go the simplest approach is to use a package called fmt which is provided by the standard library. Package fmt implements formatted I/O functions, analogous to C's printf and scanf. The format verbs are derived from C's but are simpler and there's some verbs that we can actually use if we want to go ahead and print things out. We'll talk more about verbs later on. For the meantime we're going to want to use a single function called the Println function which stands for print line. By the way fmt stands for format but typically it's called fmt. Some people do call this package fmt although I don't.

In any case the function that we're going to use from this package is the Println function which will print any of the arguments we pass to it to the console on their own line. So let's go ahead and make use of this to print to the console. In order to do so we're going to first need to import the package into our code which we can do by using the import keyword. Then we can go ahead and specify the package name that we want to import. For the standard library you just pass in the name of the package. This is slightly different when it comes to third-party packages or our own code but we'll take a look at that again later on in the course.

With the fmt package imported you can see my editor is telling me that there's an error. Go is pretty strict about unused packages, variables, etc and so it will throw an error in the event that it detects you've imported a package and haven't used it. This is a good thing as it helps to reduce compile times and also prevents you from needlessly adding to your code when you don't need to. We can go ahead and squash this error by actually using the package which we want to do by calling the Println function of it using the following syntax. First calling the package's name followed by a dot which means we're specifying a member of the package followed by the actual function we want to call which is Println.

Then we can go ahead and pass in an argument to this. The argument we want to pass in is a string value which is denoted by the double quotes either side of whatever we type in. In this case we want to type in "hello world". This means we're passing in the string of "hello world" to the Println function which we then expect to be printed on a line. With that we can now go ahead and actually run our code. If I open up a new terminal window at the bottom of the screen again I'm inside of the same directory where my main.go function is.

To run this code we can use the following command:

go run main.go

Now if I go ahead and run this code you can see "hello world" is printed to the console and we've managed to run our hello world example. In addition to running code Go also allows you to build it as well which will turn it into a binary executable that you can then distribute or just run at any time. To build code in Go you use the go build command and you can either pass in the project you want to build or just a single file. We'll take a look at projects at the start of the next module so in this case let's just go ahead and build our main.go file as follows:

go build main.go

Now if I do an ls which will list the contents of the current directory you can see I have an executable called main which is derived from the main.go name. To run this we can do:

./main

As you can see it also prints "hello world". With that we've managed to take a look at how we can install Go onto our system whilst also taking a look at a few text editing options for us to be able to use throughout this course. As I mentioned my Go version is 1.23.4 but don't worry too much about that if you happen to be using a later version as Go provides great backwards compatibility and so you can use 1.24 or in the future 1.25, 1.26 etc etc.

Not only that we've also looked at how we can actually run code using the go run command and we've also seen how we can build it using the go build command. If you are new to the language then the next few lessons are going to give a very brief overview and so I recommend taking them in order to get a good baseline. However the rest of the course will also introduce some concepts as we go through so this is going to be a very very brief introduction into things such as variables and types, conditionals and loopings and also how the package system works in Go.

Additionally each lesson will have an interactive quiz that I really recommend doing as it will help to reinforce your learning and understanding of the concepts in the lesson and it also gives me feedback on whether or not I accurately manage to teach the goal of each lesson so please do do the quiz as it helps both you and me. In any case that covers getting set up with the language. In the next one we're going to take a look at variables, values and types when it comes to Go.