Golang - Getting Started
Tags: go, softwaredevelopment, webdev
Published: 2017-11-18 12:58:27

---
title: Golang - Getting Started
published: true
description: A tutorial series on the Go Programming Language
tags: golang,softwaredevelopment,webdev,go
---
> “Go will be the server language of the future.” — Tobias Lütke, Shopify

Go was first created as an experiment, the goal of its creators was to come up with a language that would resolve bad practices of others while keeping the good things.

Its first release was on March 2012. Go was designed to feel familiar and to stay as simple as possible, the entire language specification fits in just a few pages.

## What's this series about?
This series is a gentle introduction to the Go programing language, covering the basic concepts, syntax and features of Go. The ending parts of the series would focus on building from Zero to Live app using the Go programming language.


## Why Go?
Why would you choose Golang over tonnes of other languages such as python, ruby, nodejs, etc?

Here are some of the pros I've seen in Go:

- Concurrency is an inherent part of the language. As a result writing multi-threaded programs is a piece of cake. This is achieved by Goroutines and channels (will be discussed fully in next parts of this series).

- Golang is a compiled language. The source code is compiled to native binary. This is missing in interpreted languages such as JavaScript used in nodejs.

- The language spec is pretty simple. The entire spec fits in a page and you can even use it to create your own compiler... sweet isn't it?

## Installation && Setup

Golang is supported on all the three platforms Mac, Windows and Linux. You can download the binary for the corresponding platform here - https://golang.org/dl .

### Linux setup
[Download](https://golang.org/dl) the archive and extract it into `/usr/local`, creating a Go tree in `/usr/local/go`.

```bash
tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz
```

Add `/usr/local/go/bin` to the **PATH** environment variable. You can do this by adding this line to your /etc/profile (for a system-wide installation) or `$HOME/.profile`:

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

### Mac OS X package installer
[Download](https://golang.org/dl) the package file, open it, and follow the prompts to install the Go tools. The package installs the Go distribution to `/usr/local/go`.

The package should put the /usr/local/go/bin directory in your PATH environment variable. You may need to restart any open Terminal sessions for the change to take effect. 

### Windows installation
Open the [MSI file](https://golang.org/dl/) and follow the prompts to install the Go tools. By default, the installer puts the Go distribution in c:\Go.

The installer should put the `c:\Go\bin directory` in your **PATH** environment variable. You may need to restart any open command prompts for the change to take effect. 

## Testing our Installations
To test if Go is properly installed on our machine, we need to create a workspace, and write our first program. 

We'll first create our workspace:
```bash
cd $HOME/go && mkdir test
```

Next we create our source file `test.go` with the following content:
```go

package main 

import "fmt"

func main() {
  
  fmt.Println("Hello World!")
}
```

The code above, represents a simple Go program. Every Go program is made up of packages. Our program, starts running in the package main. This program is using the package with import paths "fmt".

By convention, the package name is the same as the last element of the import path. For instance, the `fmt` package comprises files that begin with the statement package `fmt`. 

To build the program, Go provides a build tool for us to use:
```go
cd $HOME/go/test

go build test.go
```
The command above will build an executable named test in the directory alongside the source code. Execute it to see the greeting: 
```go
./test
Hello World!
```
If you see the greeting, you've been successful so far, and your Go installation works.


This is the first article in the Golang tutorial series. In the next articles, I'll be covering the following topics:

- Variables - [VIEW](https://dev.to/codehakase/getting-started-with-go---variables-aef)
- Types     - [VIEW](https://dev.to/codehakase/types-in-go-ckf)
- Constants - [VIEW](https://dev.to/codehakase/constants-in-go-92o)
- Functions - [VIEW](https://dev.to/codehakase/functions-in-go-3dd)
- Packages
- Conditional Statements and Loops
- Arrays, Slices and Variadic Functions
- Pointers, Structures and Methods
- Interfaces
- Concurrency
- Object Oriented Programming
- Defer and Error Handling

I hope you've enjoyed this part of the series? You can read other articles by me on my [Blog](https://hakaselabs.github.io) or on [The Practical Dev](https://dev.to/codehakase).

If I've missed anything, let me know in the comments.