# ⭐️Demystifying Go: A Beginner's Guide to Understanding Go Language Code 👨🏻‍💻

***#90DaysOfDevOps***

### **Day-9: Understand the code in GOLANG**

**Go Language: A Brief Introduction**

Go is a programming language developed by Google in 2009. It is a statically typed, compiled language that is known for its simplicity, performance, and concurrency support. Go is a popular choice for developing web applications, microservices, and distributed systems.

Go was introduced to tackle evolution of infrastructure that many existing languages couldn't take advantage of it.

**Go Code**

Go code is written in a human-readable format that is easy to understand and maintain. Go code is organized into packages, which are collections of related files. Each package has a main function, which is the entry point for the program.

* The `fmt` package provides functions for formatting text.
    
* The `math` package provides functions for mathematical operations.
    
* The `net` package provides functions for networking.
    
* The `os` package provides functions for interacting with the operating system.
    
* The `time` package provides functions for working with time.
    
    ```go
    import 'fmt'
    import 'math'
    import 'os'
    ```
    

**Go Variables**

Go variables are declared using the var keyword. The var keyword is followed by the variable name, the variable type, and an optional initializer. For example, the following code declares a variable named x of type int:

```go
var a int
```

**Go Functions**

Go functions are declared using the func keyword. The func keyword is followed by the function name, the function parameters, and the function body. For example, the following code declares a function named f that takes two int parameters and returns an int:

```go
func f(a, b int) int {
  return a + b
}
```

**Go Control Flow Statements**

Go supports a variety of control flow statements, including if, else, for, and switch statements. For example, the following code uses an if statement to print the value of x if it is greater than 10:

```go
if a > 10 {
  fmt.Println(x)
}
```

**Go Loops**

Go supports a variety of loops, including for, while, and range loops. For example, the following code uses a for loop to iterate over the elements of an array:

```go
for i := 0; i < len(array); i++ {
  fmt.Println(array[i])
}
```

**Go Error Handling**

Go supports error handling through the use of the error type. The error type is a value that can be used to represent an error condition. For example, the following code uses the error type to check if a function call has failed:

```go
err := f()
if err != nil {
  fmt.Println(err)
}
```

**Go Concurrency**

Go is a **coexisting** language, which means it can support multiple tasks running at the same time. Go concurrency is **attained** through the use of go routines and channels. Go routines are lightweight threads that can be created and **handled** by the Go runtime. Channels are a way **to** **send** and **receive** data between goroutines.  
  
Conclusion  
  
Go is a **dynamic** and **flexible** programming language that is **convenient** for a variety of tasks. Go code is easy to read and maintain, and **Go's** concurrency support makes it a great choice for developing complex applications. 

If you are interested in learning more about Go, there are a number of resources available online. And few resources mentioned below:

Go official website: [https://golang.org/](https://golang.org/)

To practice hands-one: [https://play.golang.org/](https://play.golang.org/)

TechWorld with Nana: [https://youtu.be/yyUHQIec83I](https://youtu.be/yyUHQIec83I) (*3 hours complete course*)

Tech with Tim: [https://youtube.com/playlist?list=PLzMcBGfZo4-mtY\_SE3HuzQJzuj4VlUG0q](https://youtube.com/playlist?list=PLzMcBGfZo4-mtY_SE3HuzQJzuj4VlUG0q) (*Complete Go Lang basics topic wise*)