GoLang Tutorial - HelloWorld

In 2009, Google made Go, often called Golang. It's like C, being statically typed and explicit. Go is known for quick startup and low runtime overhead. People love using it for microservices and concurrent programming.

Download an appropriate package from https://go.dev/doc/install.

The package installs the Go distribution to /usr/local/go. The package should put the /usr/local/go/bin directory in our PATH environment variable.

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

$ go version
go version go1.21.4 darwin/amd64

To try out GoLang, follow these steps to ensure that Go is installed correctly and set up a workspace by building a simple program:

1. Check Go Installation: Verify that Go is installed correctly on your system.
2. Set Up Workspace: Create a workspace directory. For example, we can use the following command to create a directory named go in our home directory:

   $ mkdir -p $HOME/go
   

   This will be our Go workspace directory.
3. hello.go:

   package main
   
   import "fmt"
   
   func main() {
     fmt.Println("Hello, world!")
   }
   

Now we're ready to proceed with building a simple program in our newly set up Go workspace.

We should use go mod init command to create a Go module for our hello world code. This will make it easier to manage our dependencies and share our code with others:

$ go mod init example/hello
go: creating new go.mod: module example/hello
go: to add module requirements and sums:
        go mod tidy    

The go mod init command in Go is used to initialize a new module. A module is a collection of related Go packages that are versioned together as a single unit. The go mod init command is typically run at the root of our project to create or initialize a go.mod file, which contains information about the module and its dependencies.

The example/hello is the module path. It uniquely identifies our module and its location in our version control system. It is common practice to use a path that resembles the directory structure of our project. I n this case, it suggests that our project is inside a directory named example, and the module is named hello.

Navigate to the directory where we saved the hello.go file and run the following command to build our code:

$ go build

Then, run the following command to run our code:

$ ./hello

We should see the following output:

Hello, world!

We have written and run our first Golang code!

Well, we can do a little bit more, adding time:

package main

import (
  "fmt"
  "time"
)

func main() {
  fmt.Println("Hello, world!")
  fmt.Println("The time is ", time.Now().Format("2006-01-02 15:04:05"))
}    

Note that we're formating time.Time type func() using the appropriate format placeholders corresponding to the components of the time we want to display, and these placeholders are fixed. Actually, in the time package in Go, the reference time for formatting dates and times is January 2, 2006, at 15:04:05 (3:04:05 PM) MST. This specific date and time were chosen by the creators of Go as a memorable and easy-to-remember reference point for formatting purposes.

Also note that we're importing "time" package.

Modules vs Packages:

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)