main package and main function in Go - Step-by-Step Execution

Concept Flow - main package and main function

Start program

↓

Find package main?

Yes↓

Find func main()?

Yes↓

Execute func main()

↓

Program ends

The Go program starts by looking for the main package and then runs the main function inside it.

Execution Sample

Go

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

This program prints 'Hello, Go!' by running the main function inside the main package.

Execution Table

Step	Action	Evaluation	Output
1	Start program	Look for package main
2	Found package main	Look for func main()
3	Found func main()	Prepare to execute main
4	Execute fmt.Println("Hello, Go!")	Print string to console	Hello, Go!
5	End of func main()	Program finishes

💡 Program ends after main function completes

Variable Tracker

Variable	Start	After Step 4	Final
No variables	-	-	-

Key Moments - 3 Insights

Why must the package be named 'main'?

Because Go only runs the program starting from the 'main' package, as shown in step 1 and 2 of the execution table.

What happens if there is no main function?

The program will not run because Go looks for func main() to start execution, as seen in step 3.

Why does the program print 'Hello, Go!'?

Because inside func main(), fmt.Println is called to output the string, shown in step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the output at step 4?

A No output

B "Hello, Go!"

C "Hello, World!"

D Error message

💡 Hint

Check the Output column at step 4 in the execution table

At which step does the program find the main function to execute?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the Action column to see when func main() is found

If the package was named 'utils' instead of 'main', what would happen?

A Program does not run because no main package

B Program runs normally

C Program prints 'Hello, Go!' anyway

D Program runs but main function is ignored

💡 Hint

Refer to step 1 and 2 where Go looks for package main

Concept Snapshot

package main is required to create an executable program in Go.
func main() is the entry point where execution starts.
The program runs by executing main function inside main package.
Without package main or func main(), the program will not run.
Use fmt.Println inside main to print output.

Full Transcript

In Go, the program starts by looking for the package named main. This is important because only the main package can be run as a program. Once the main package is found, Go looks for the main function inside it. The main function is the starting point of the program. When Go finds func main(), it executes the code inside it. In our example, the main function calls fmt.Println to print 'Hello, Go!' to the console. After the main function finishes, the program ends. If the package is not named main or if there is no main function, the program will not run. This is why both package main and func main() are essential for a Go program to execute.

Practice

1. What is the purpose of the main package in a Go program?

easy

A. It contains only variable declarations.

B. It is used to import external libraries only.

C. It defines the entry point where the program starts running.

D. It is used to define custom data types.

Solution

1. Step 1: Understand the role of the main package

   The main package is special in Go because it tells the compiler this is an executable program, not a library.

2. Step 2: Identify the program start point

   Within the main package, the main function is the starting point where execution begins.

3. Final Answer:

   It defines the entry point where the program starts running. -> Option C

4. Quick Check:

   main package = program entry [OK]

Hint: Remember: main package means program starts here [OK]

Common Mistakes:

• Thinking main package is only for imports
• Confusing main package with libraries
• Assuming main package holds only variables

2. Which of the following is the correct way to declare the main function in Go?

easy

A. func main() {}

B. function main() {}

C. def main() {}

D. main func() {}

Solution

1. Step 1: Recall Go function syntax

   In Go, functions are declared with the keyword func, followed by the function name and parentheses.

2. Step 2: Check the main function declaration

   The main function must be declared as func main() {} with no parameters and no return values.

3. Final Answer:

   func main() {} -> Option A

4. Quick Check:

   Go functions start with func [OK]

Hint: Go functions start with 'func' keyword [OK]

Common Mistakes:

• Using 'function' instead of 'func'
• Using Python or JavaScript syntax
• Placing 'func' after the function name

3. What will be the output of this Go program?

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

medium

A. fmt.Println("Hello, Go!")

B. No output, program error

C. package main

D. Hello, Go!

Solution

1. Step 1: Understand the program structure

   The program imports the fmt package and calls fmt.Println inside main to print a string.

2. Step 2: Predict the output

   The fmt.Println function prints the string with a newline, so the output is exactly: Hello, Go!

3. Final Answer:

   Hello, Go! -> Option D

4. Quick Check:

   fmt.Println prints text [OK]

Hint: fmt.Println prints text to console [OK]

Common Mistakes:

• Expecting code to print the code itself
• Confusing package name with output
• Thinking program will error without main

4. Identify the error in this Go program:

package main
func main() {
    fmt.Println("Hello")
}

medium

A. main function must return a value

B. Missing import of fmt package

C. package name should not be main

D. fmt.Println syntax is incorrect

Solution

1. Step 1: Check for required imports

   The program uses fmt.Println but does not import the fmt package, which is required to use it.

2. Step 2: Understand Go import rules

   Without importing fmt, the compiler will raise an error because fmt is undefined.

3. Final Answer:

   Missing import of fmt package -> Option B

4. Quick Check:

   Use import for external packages [OK]

Hint: Always import packages before using them [OK]

Common Mistakes:

• Forgetting to import fmt
• Thinking main must return a value
• Changing package main to something else

5. You want to create a Go program that prints "Welcome!" only when run directly, but not when imported as a package. Which setup is correct?

hard

A. Use package main and define func main() { fmt.Println("Welcome!") }

B. Use package main but define func welcome() { fmt.Println("Welcome!") }

C. Use any package and define func main() { fmt.Println("Welcome!") }

D. Use package main and define func init() { fmt.Println("Welcome!") }

Solution

1. Step 1: Understand package main role

   Only programs with package main and a main function are executable directly.

2. Step 2: Identify correct function to run on start

   The main function is the entry point; code inside it runs only when program runs directly.

3. Step 3: Compare options

   Use package main and define func main() { fmt.Println("Welcome!") } uses package main and main function correctly. Use package main but define func welcome() { fmt.Println("Welcome!") } defines a different function that won't run automatically. Use any package and define func main() { fmt.Println("Welcome!") } uses any package, which won't create an executable. Use package main and define func init() { fmt.Println("Welcome!") } uses init(), which runs on import too.

4. Final Answer:

   Use package main and define func main() { fmt.Println("Welcome!") } -> Option A

5. Quick Check:

   package main + main() = executable start [OK]

Hint: Only package main with main() runs directly [OK]

Common Mistakes:

• Using init() instead of main() for start
• Using non-main package for executable
• Defining functions not named main