Get _go_ ing by learning the basics of Google's very own programming language, Go! 

Learn Go: Introduction

Now that we know how to declare & use Go packages, let's look through the rest of the code: 

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

#### `main` Function ####

We use the `func` keyword to declare the [Go function](https://www.codecademy.com/content-items/22ba32684094429aa3d0066e5bc1a274?draft=true&bypass_cache=true) `main`:
* The `func` keyword denotes the start of a function declaration.
* `func` is followed by the name of the function: `main`. 
* After the name there follows a pair of parentheses `()` and a set of curly braces `{}`. 
* The function code is written inside the set of curly braces. 

#### Function Code ####

The code inside a function is indented. The code here invokes the `Println` function in the `fmt` package (that we imported earlier) to print the message `"Hello World"`. 

#### Invoking Functions ####

Normally when we write functions, you need to write code to *invoke* them, otherwise they are unused. However, the `main` function is *different* if it resides in the `main` package.

When we have a `main` function in the `main` package, this is special to Go. When compiled, an executable is produced, and when run, the executable uses the `main` function as the starting point.

Our Program So Far: main Function 

Previously, we imported a single package, `fmt`.  This package is useful but it is only one in a [list of many included with Go](https://golang.org/pkg/).

The standard packages are so useful that you will often use multiple packages in each `.go` file.


#### Importing Multiple Packages

To import multiple packages, we can add multiple `import` statements:

```go
import "package1"
import "package2"
```

Or use a single `import` with parentheses:

```go
import (
  "package1"
  "package2"
)
```

#### Package Aliases

We can also provide an _alias_ to a package by specifying an alias name before the package name. 

```go
import (
  p1 "package1"
  "package2"
)
```

In the example above we've aliased `package1` as `p1` and now we can call functions from `package1` by using `p1` like: 

```go
p1.SampleFunc()
```
 Instead of:
```go
package1.SampleFunc() 
```

Importing Multiple Packages

Great job! We've just finished your first Go lesson! In this lesson we learned about: 

* What Go/Golang is & what its used for.
* The Go compiler. 
* Go Packages, including the `main` for executables.
* Go Functions, including the `main` function.
* Comments
* Resources, including `go doc`.

If you're interested in setting up your computer to create Go programs on your own computer, use our [guide for developing Go locally](https://www.codecademy.com/articles/setting-up-go-locally)!

Review

Now we know what Go is for, let's learn how to use the Go Compiler to compile a file into an executable. 

In our terminal, we type in `go build` followed by the name of our file and press <kbd>Enter</kbd>. If we wanted to run a file called `greet.go`, the command will look like:

```
go build greet.go
```

While nothing obvious is shown after we run our command, Go has created our program's executable file. If we type in the command `ls`, we'll see our original Go program and its executable file.

```
ls
greet     greet.go
```

To execute the file, we call:

```
./greet
```

Now let's _go_ one step further and actually do it! 


Compiling Files

Now that we understand how to compile and run Go programs, let's take a look at Go packages. 

Projects can contain many `.go` files, organized into packages. Each package is like a directory: `.go` files to do with one part of your program can go in one package, other `.go` files to do with something else can go into another package. If we were writing a calculator program, we could put the files for the calculation in package `calc` and the files for input & output in package `io`.

#### Our Program So Far

```go
package main 

import "fmt" 

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

##### Package Declaration

Let's focus on the first line `package main`. This line is called a _package declaration_ and it tells the Go compiler to which package this '.go' file belongs. If this package declaration is 'package main', then this program will be compiled into an executable.

##### Whitespace 

Next is a blank line. Go generally ignores these blank lines, they're considered _whitespace_ (new lines, spaces, and tabs). While our program doesn't need the line break, it makes our code easier to read.

##### Import Statement

Then we have an _import statement_, `import "fmt"`. The `import` keyword allows us to use code from other packages, in this case the `Println` function from the `fmt` package. Note how the package name is enclosed with double quotes `"`. 


Now that we know how we declare & use Go packages, let's discuss functions. 


Our Program So Far: Packages

Now we have completed the basics of using packages, let's move on to comments.

#### Before Commenting...

"Don’t comment bad code — rewrite it." — Brian W. Kernighan and P. J. Plaugher.  

Try to make code as clean and self-explanatory _before_ adding comments. They should be the icing on the cake rather than the filling!

Comments are useful for:
- Explaining what the code does & why something was done a certain way
- Outlining important or fragile blocks of code, which require extra care
- Noting down what we need to do when we are writing the code
- Disabling code without deleting it
- Adding information to be picked up by the `go doc` tool (more on that later)
 
#### Types
There are two types of comments in Go. 

##### Line Comments

Line comments start with a `//` and the rest of the line is ignored by the compiler.

```go
// This entire line is ignored by the compiler
// fmt.Println("Does NOT print")
fmt.Println("This gets printed!") // This part gets ignored
```
Note how you can add a `//` _after_ the code, _without affecting it_.

##### Block Comments

Block comments can span multiple lines.
They start with a `/*` and end with a `*/`, enveloping everything inside:

```go
/*
This is ignored.
This is also ignored. 
fmt.Println("This WON'T print!")
*/
```
In the example above we've commented out all three lines using a block comment.
<br>
<br>

Now let's use some comments in our own code! 


Comments

There are many resources available to help us learn Go.

##### Go Doc #####

Go includes a program `go doc` for extracting and viewing documentation from `.go` files.
For information about a package, use the command `go doc` followed by the package name. 
```
go doc fmt 
```

For information about a package function, use the command `go doc` followed by the package name, a period then the function name.

```
go doc fmt.Println
```

##### Google's Go Website

* [Go's official website](https://golang.org/)
* [Go's official documentation](https://go.dev/doc/)

##### Other Websites

* [Codecademy's Forums](https://discuss.codecademy.com)
* [Stack Overflow's Go questions](https://stackoverflow.com/questions/tagged/go) 

##### Google Search

When searching for information about Go, you may want to consider searching **Golang** instead of **Go**, as it is more specific.


Go Resources

Great, we were able to use the Go compiler to build an executable. We can run that executable as many times as we want.

But what happens if we ever wanted to change our program? We would have to compile another executable file and then run that file. Imagine having to do that every single time!

Thankfully, we have the `go run` command followed by the name of the Go file. We can use the `go run` command like so:

```
go run greet.go
```

The `go run` command compiles the code (like `go build`) and executes it. Unlike `go build`, `go run` will NOT create an executable file in our current folder.



Running Files

Go, or Golang, is a language that was [developed by Google](https://go.dev/) for in-house software development, to make their software easier to write, maintain and build.

Go has quickly become very popular in the world of development, often used for writing APIs and DevOps tools. Go sits in the middle between low-level languages and high-level languages, often offering the advantages of both. 

Go:

-   Uses a similar syntax to many other languages, including ‘C’.
-   Produces code that runs fast and uses very little memory.
-   Run across many platforms.
-   Provides simple syntax for multi-threaded programs.
-   Provides some object-oriented features.
-   Has garbage collection.

Before we can make full use of Go, we first have to learn how to read and run a Go program. Once you've finished the entire lesson, read our [guide for developing Go locally](https://www.codecademy.com/articles/setting-up-go-locally) to compile and run Go programs on your own computer!

