Golang love

Why Go ?

Introduction

Learning resources

Local setup

Attribution

Well , hello there !

This is a gentle introduction to Go (also known as Golang) , a general purpose programming language developed and backed by Google, to tackle some of the issues they have faced at Google. This language promises to be a modern programming language.

Who built Go ?

It was developed in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson at Google but launched in 2009 as an open-source programming language.

Advantages of Go ?

Go or Golang is a robust system level language used for programming across large-scale network servers and big distributed systems. It is easy, simple and evocative. It offers more than just simplicity... Here is list of advantages:

Statically typed language with a GC (garbage collector) provides strong type safety to avoid bugs.
Fast compilation and execution
Facilitates easy versioning of program
No Generics
Single executable generated on build , cross-platform (compilation target can be set to Linux, Windows executable), no hassle of handling dependency.

Golang is used to build large distributed networks, commandline tools and much more.

Did you know ?

Some of the most advanced applications are built using Go and I am sure you must heard of them, even if you might have not used them.

Docker: The future of app packaging with distributed computing.
Kubernetes: The future of seamlessly automated deployment processes.
Hugo: One of the fastest static site generator
Golang: The language is built using go itself.

That's a lot of reason to get me interested in Go as a web developer and who has dabbled in backend development for a while.

Let's get started with some basic concepts of Go:

Packages
Every Go program is made up of packages. Programs start running in package main. This program is using the packages with import paths "fmt" and "math/rand".
```
package main

import (
"fmt"
"math/rand"
)

func main() {
fmt.Println("My favorite number is", rand.Intn(10))
}

                    
```
Variables
The var statement declares a list of variables; as in function argument lists, the type is last. A var statement can be at package or function level. We see both in this example.
```
package main

import "fmt"

var c, python, java bool

func main() {
var i int
fmt.Println(i, c, python, java)
}

                        
```
Functions
A function can take zero or more arguments. In this example, add takes two parameters of type int. Notice that the type comes after the variable name.
```
package main

import "fmt"

func add(x int, y int) int {
return x + y
}

func main() {
fmt.Println(add(42, 13))
}

                        
```
Basic types

Go's basic types are
- bool
- string
- int : int8 int16 int32 int64
- uint : uint8 uint16 uint32 uint64 uintptr
- byte // alias for uint8
- rune // alias for int32 // represents a Unicode code point
- float32 float64
- complex64 complex128

Type conversions

The expression T(v) converts the value v to the type T.


package main

import (
"fmt"
"math"
)

func main() {
var x, y int = 3, 4
var f float64 = math.Sqrt(float64(x*x + y*y))
var z uint = uint(f)
fmt.Println(x, y, z)
}

Do you want to know more or practice more such examples ? Visit the link below:

Tour of Go

Packages

Variables

Functions

Basic types

Type conversions