This module is perfect for beginners to learn Go. Discover Go core constructs, advanced error handling, and networking techniques for aspiring Go programmers and Go developers.

Golang for Programmers

Go (also called Golang) is one of the most popular languages today and is a key part of many enterprise tech stacks. Many developers prefer Go to other languages like C++ and Scala because of its memory management model, which allows for easier concurrency.
In this module, you will learn Go and the core constructs and techniques of the language. After going through the basics, you will then learn more advanced Go concepts like error-handling, networking, and templating. You'll learn how to program efficiently in Go by gaining knowledge of common pitfalls and patterns, as well as by building your own applications. This module is perfect for aspiring Go developers and those who are Go beginners seeking to become proficient Go programmers.

Learn Go

## Problem statement
Write a function that returns the __factorial__ (!) of any `n` number.
The factorial $n!$ of a number $n$ is defined as: 

$n! = n * (n – 1)! , where 0!=1 and 1!=1$

For example:  __$5! = 5*4*3*2*1= 120$__
## Input
A number of type __uint64__, `n`
## Output
A number of type __uint64__ (because the number increases drastically due to multiplication)

Results will be correct until only `21!`. After that, the _overflow-error_ will occur.
>__Remark__: When using type _int_ the calculation is only correct up until `12!`. This is, of course, because an _int_ can only contain integers that fit in 32 bits. And, Go doesn’t usually warn against this overflow-error! 
## Sample input
```go
10
```
## Sample output
```go
3628800
```
Try to implement the function below. Feel free to view the solution, after giving some shots. Good Luck!

# Problem statement
Write a function that returns the __factorial__ (!) of any `n` number.
The factorial $n!$ of a number $n$ is defined as: 

$n! = n * (n – 1)! , where 0!=1 and 1!=1$

For example:  __$5! = 5*4*3*2*1= 120$__
# Input
A number of type __uint64__, `n`
# Output
A number of type __uint64__ (because the number increases drastically due to multiplication)

Results will be correct until only `21!`. After that, the _overflow-error_ will occur.
>__Remark__: When using type _int_ the calculation is only correct up until `12!`. This is, of course, because an _int_ can only contain integers that fit in 32 bits. And, Go doesn’t usually warn against this overflow-error! 
# Sample input
```go
10
```
# Sample output
```go
3628800
```
Try to implement the function below. Feel free to view the solution, after giving some shots. Good Luck!

This lesson brings you a challenge to solve.

Introduction to Go

Go Data Types and Variables

Go if-else, switch-case,Construct, break and continue

Go Functions

Go Slices and Arrays

Wrap Up

Problem statement