Through the first part of this course, we're going to be building a simple CLI application that will allow us to count the number of words found inside of a text file. Initially, we're going to start with a really simple implementation, but we'll slowly build it out throughout the first half of the course, adding in some more advanced features as we learn more advanced topics in Go. Therefore, the goal of this lesson is to just get a project up and running, printing out a simple hello word counter to the screen, so that we can begin working from it in other lessons.

So let's go ahead and do so, and begin by creating a new project. To do so, I'm going to go ahead and make a new directory inside of my projects directory called counter. This is where all of the code for this project is going to live. In my case, I'm creating this project using the mkdir command, which will create a directory inside of the directory that I'm currently in. You can also tell this command to create directories inside of absolute paths, such as mkdir ~/, which sets the user's root projects counter.

In any case, with the counter directory created, the next thing to do is to go ahead and change into it by using the cd command. Now you can see I'm inside of my counter directory, which is inside of my user's home folder at /home/elliott, and inside of the Projects/counter directory. Then once inside, we can go about creating a new project. Rather than just creating a main.go file like we did inside of Go 101, instead we want to set this to be a full project using the go mod command. The mod in go mod is short for modules, and it's how Go manages dependencies.

You can think of a go.mod file as being similar to say a package.json, where it stores all of the modules inside of your actual Go project inside of a go.mod file. We'll take a look at that file shortly. For the meantime, however, we just want to go ahead and actually create it using the go mod init command, which, if we take a look at the documentation for, tells us that the go mod init command initializes and writes a new go.mod file in the current directory, in effect creating a new module rooted at the current directory, or a new project. You can think of projects and modules as being interchangeable.

The go.mod file must not already exist, which in our case, it doesn't. The init command accepts one optional argument, the module path for a new module. In this case, it says a module path is the canonical name for a module, declared with the module directive in the Go's go.mod file. A module path is the prefix for package paths within the module. Therefore, choosing a correct module path is going to be important.

If we take a look at the documentation for the actual go.mod file, you can see it gives some information about what the module path should be. As it says, the module path is usually the repository location from which the module can be downloaded by Go tools. And it gives a couple of examples, as you can see, such as example.com/my-module, where you would substitute example.com for a repository domain from which this module could be downloaded. This is pretty useful to know when it comes to building command line applications with Go. As if you want to publish this code, by making it available on a repository that's publicly accessible, defining the module name as the path to that repository allows other users to easily download and install your application using the go install command.

If you don't plan on publishing this code, then you can set this to be an internal repository or just a URL that you own. In this case, because we would eventually want other users to download and use this word counter tool if they desired, then it's worthwhile to set this to be a public repository name. So in my case, I'm going to set this to be github.com/dreamsofcode-io/counter. When it comes to your own go mod init command, I would recommend replacing this with your own username, whichever that may be.

In any case, with githib.com/dreamsofcode-io/counter module name defined, we can go ahead and run this code, and you can see that the tool tells us that it's created a new go.mod with the following module. If we take a look at the directory using the ls command, you can see that the go.mod file now exists, which, if I go ahead and use the cat command to print out, here you can see some information about go.mod. First of all, the module name, which is what we defined in the go mod init command, as well as the version of Go that was used to create this Go module, which in my case is version 1.23.4, which is the latest version at the time of recording.

In any case, with our go.mod file now defined, we can go about creating our main function, similar to what we did in Go 101. To do so, I'm going to go ahead and create it using my text editor, which is NeoVim, using the mvim main.go command, which will create and open up the file for me to be able to edit. To begin, let's go ahead and define the package name, which again is going to be main, as this is an application that we're building, and therefore the main package is needed as the entry point, followed, of course, by the main function.

Next, for this initial iteration of this application, we just want to go ahead and print out the words, "hello word counter." So, we can go ahead and import the fmt package, as follows, and then call the Println function of the fmt package, passing in "Hello Word Counter." Pretty simple.

Now, if I go ahead and open up a new terminal window, we can go ahead and test that this code is working by using the go run command. However, this time, rather than calling the main.go file, instead, we can use the dot syntax, given the fact that we're using a module, and we want to compile all of the code inside. So, if we go ahead and run this command, you can see "hello word counter" is printed to the console. So far, so good.

The next thing we want to do is to go ahead and turn this project into an actual git repository, which will allow us to easily track the changes that we make to this code, and revert them back if there's ever an issue. To do so, you're going to need to have git installed on your system, which, depending on your operating system, can be installed a number of different ways. If you're on macOS, it should be available to you already if you installed the Xcode command line tools. If you're on Windows using Windows Subsystem for Linux, which I recommend through this course, then you'll likely need to install it using either apps, or again, it should already be available on your system.

If you want to check that it's available on your system, you can use the which command, pointing it at git, which will tell you where it's actually installed. In my case, you can see it's installed here. If you're running a Linux system, then you can go ahead and make use of your package manager. For example, if you happen to be using Arch, you can go ahead and use pacman to install git as follows. As you can see, I already have it installed, so there's going to be no extra changes here. Or if you happen to be using NixOS, which is what I'm using as my host system, you can install it through your Nix configuration, or just run it through the Nix shell.

In any case, once you have git installed, we can go about setting this up to be a git repository, which we're going to do using the command line, given that we're talking about command line applications in this course. To do so, go ahead and use the git init command, which will initialize an empty git repository in the following directory, /home/elliot/projects/counter/.git. Then you can go ahead and do a git status command, and it will show you what changes need to be added into your git repository. In your case, you should have the following go.mod and main.go file. If you have anything additional here, we don't want to track these in at these changes.

So let's go ahead and add this in as follows, using the git add command, adding in go.mod and main.go. Then we can go ahead and commit this using the git commit command, passing in the message of "initial commit." And there we go, we've created our first initial commit, and our code is now being tracked.

However, before we move on to the next lesson, there's one last thing we need to do. If I go ahead and run the go build command, which will build our binary for us. As you can see, we now have the counter binary or counter executable inside of our code. We can go ahead and run this by using the ./counter command on a Unix system, and it will print out the words "hello word counter," the same as if we run the go run command.

However, because we're now using git, we have a bit of an issue. For example, if I run git status, you can see that we now have the binary as an untracked file inside of our project. When it comes to binaries, we don't actually want these to be committed to our code. This is because when it comes to git, a good rule of thumb is you should never add generated files into your git repository, be it application binaries, generated code, etc. If something's generated and not written by hand, you don't want to track it. This is because they can easily start to bloat your git repository, and also, if you can generate it in the first place, you should be using your code to generate that file, rather than tracking those changes.

Therefore, we want to make sure we don't accidentally add this file into our git repository, which will cause our code to bloat. Therefore, in order to prevent that happening with git, we can use what's known as a .gitignore file, which specifies intentionally untracked files to ignore. If you take a look at the git documentation, it provides some more information about how to actually use the git ignore file, and I'll leave a link to it in the lesson description down below.

In any case, this file will allow us to specify any files we don't want to be added or tracked. One thing to note is that it only works for files that haven't yet been added into your tracked repository. So this is a good time to get started sooner rather than later. To create the .gitignore file, we have a couple of different approaches. We could just create it inside of our actual text editor as follows. However, instead, I'm going to show you how we can create it using command line kung fu.

Before we do that, the idea of the .gitignore file is you just specify the files or directories. Let's say we had a directory called gen, which was for generated code. You specify each file or directory that you want to ignore in each line of your actual project. For example, one common thing to add is the .DS_Store file, which is often found when it comes to macOS file systems. In this case, by specifying the .DS_Store file in this way, we will prevent any .DS_Store files from being added to our project.

In any case, as I mentioned, we're going to use the command line to actually write to this file, which we can do by using the echo command. The echo command will print any of the output we pass into it to stand it out. For example, if I echo foo, you can see foo appears on my terminal. By using this command, we can then go ahead and actually write data to files by piping them in using command line pipes. The pipe we want to use is the following greater than operator, which will pipe the output of the previous command into a file.

Therefore, let's go ahead and use it to pipe the counter line into the .gitignore file, which we can do as follows. Now, if I go ahead and check this file, you can see it contains a line called counter, which if I go ahead and open up, you'll see is written as well. Now, if I run git status, you can see that the counter binary is no longer appearing in the untracked files, although the .gitignore is because we haven't yet added it.

Before we add it, let's also go ahead and add in the .DS_Store file as well, which again we can do by piping the output of our echo command. However, there is an issue if we go ahead and use the same command we did before. To show what this issue is, if I go ahead and run it, you can see now if I check the .gitignore file, we no longer have the line that specifies our counter. And if I run git status again, you can see the counter binary is in the untracked files.

This is because the greater than expression will truncate the file that it writes to, meaning it will clear all of the existing data inside. Therefore, if we want to append to this file rather than truncate, we need to use the double greater than expression, which instead of truncating will append. For example, if I go ahead and echo counter using this operator to the .gitignore, and if I go ahead and print out the contents of the .gitignore file, you can see now it has a line for the .DS_Store that we specified before, and it has a line for our counter.

And if I run git status, you can see the .gitignore file is untracked and our counter no longer is. With that, let's now go ahead and add the .gitignore to the git repository as follows, and commit it with the following message of "added in a .gitignore to prevent unwanted files," let's say. With that, our project is now up and running and initialized, and we're in a good state to start adding in some features to our word counting application. In the next lesson, we're going to take a look at how we can actually load data into our application by reading it in from a file.