Writing first Go program - Step-by-Step Execution

Concept Flow - Writing first Go program

Start program

↓

Import fmt package

↓

Define main function

↓

Execute fmt.Println("Hello, world!")

↓

Print output to screen

↓

Program ends

The program starts, imports the fmt package for printing, runs the main function, prints the message, then ends.

Execution Sample

Go

package main

import "fmt"

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

This program prints 'Hello, world!' to the screen.

Execution Table

Step	Action	Evaluation	Result
1	Start program	N/A	Program begins execution
2	Import fmt package	N/A	fmt package loaded for printing
3	Define main function	N/A	main function ready to run
4	Call fmt.Println with "Hello, world!"	fmt.Println("Hello, world!")	Prints Hello, world! to screen
5	End main function	N/A	Program finishes

💡 Program ends after printing the message.

Variable Tracker

Variable	Start	After Step 4	Final
N/A	N/A	N/A	N/A

Key Moments - 3 Insights

Why do we need to import the fmt package?

The fmt package provides the Println function used to print text. Without importing it, the program cannot print anything. See step 2 in the execution table.

What is the main function for?

The main function is the starting point of the program where execution begins. The code inside main runs first. See step 3 and 4 in the execution table.

Why does the program end after printing?

After the main function finishes running, the program has no more instructions and stops. See step 5 and exit note.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 4?

A The program ends

B The program imports the fmt package

C The program prints 'Hello, world!' to the screen

D The main function is defined

💡 Hint

Check the 'Action' and 'Result' columns at step 4 in the execution table.

At which step does the program finish running?

A Step 5

B Step 3

C Step 2

D Step 1

💡 Hint

Look at the 'Step' and 'Result' columns to find when the program ends.

If we remove the import statement, what will happen?

A The program will print 'Hello, world!' anyway

B The program will fail because fmt.Println is undefined

C The program will run but print nothing

D The program will end immediately

💡 Hint

Refer to the key moment about why importing fmt is necessary.

Concept Snapshot

Go program starts with package main
Import fmt package to print
Define main() function as entry point
Use fmt.Println() to print text
Program runs main, prints, then ends

Full Transcript

This Go program starts by declaring package main, which is required for executable programs. It imports the fmt package to use its Println function for printing text. The main function is defined as the program's entry point. Inside main, fmt.Println("Hello, world!") prints the message to the screen. After printing, the program ends because main finishes execution.

Practice

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

easy

A. It is the starting point where the program begins execution.

B. It defines a package for the program.

C. It imports external libraries.

D. It declares variables for the program.

Solution

1. Step 1: Understand the role of main function

   The main function is special in Go; it is where the program starts running.

2. Step 2: Differentiate from other parts

   Packages define code grouping, imports bring libraries, and variables store data, but none start execution.

3. Final Answer:

   It is the starting point where the program begins execution. -> Option A

4. Quick Check:

   Program starts at main() -> D [OK]

Hint: Remember: main() is the program's entry point [OK]

Common Mistakes:

• Confusing package declaration with program start
• Thinking imports start the program
• Assuming variables control program flow

2. Which of the following is the correct way to print "Hello, Go!" in a Go program?

easy

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

B. print("Hello, Go!")

C. fmt.print("Hello, Go!")

D. console.log("Hello, Go!")

Solution

1. Step 1: Identify the correct print function in Go

   Go uses the fmt package with Println to print with a newline.

2. Step 2: Check syntax correctness

   fmt.Println("Hello, Go!") is correct; others are either wrong function names or from other languages.

3. Final Answer:

   fmt.Println("Hello, Go!") -> Option A

4. Quick Check:

   Use fmt.Println() to print lines in Go [OK]

Hint: Use fmt.Println() for printing with newline [OK]

Common Mistakes:

• Using fmt.print instead of fmt.Println
• Using print() which is not standard in Go
• Using console.log from JavaScript

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

package main
import "fmt"
func main() {
    fmt.Println("Welcome to Go!")
}

medium

A. package main
import "fmt"
func main() {
fmt.Println("Welcome to Go!")
}

B. fmt.Println("Welcome to Go!")

C. Welcome to Go!

D. Error: missing main function

Solution

1. Step 1: Understand program structure

   The program imports fmt and defines main(), which prints the string.

2. Step 2: Identify output of fmt.Println

   It prints the string exactly: Welcome to Go! with a newline.

3. Final Answer:

   Welcome to Go! -> Option C

4. Quick Check:

   fmt.Println prints string output [OK]

Hint: fmt.Println prints the string content, not code [OK]

Common Mistakes:

• Confusing code with output
• Expecting code to print itself
• Thinking main function is missing

4. Identify the error in this Go program:

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

medium

A. Missing import statement

B. Incorrect function name

C. Missing package declaration

D. Missing closing parenthesis in fmt.Println call

Solution

1. Step 1: Check syntax of fmt.Println

   The call to fmt.Println is missing a closing parenthesis at the end.

2. Step 2: Verify other parts

   Package and import are present, function name is correct, so no errors there.

3. Final Answer:

   Missing closing parenthesis in fmt.Println call -> Option D

4. Quick Check:

   Check parentheses in function calls [OK]

Hint: Count opening and closing parentheses carefully [OK]

Common Mistakes:

• Forgetting closing parenthesis in function calls
• Assuming missing import or package causes this error
• Misnaming main function

5. You want to write a Go program that prints "Hello" on one line and "World" on the next line. Which code snippet achieves this correctly?

hard

A. package main
import "fmt"
func main() {
fmt.Print("Hello\nWorld")
}

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

C. package main
import "fmt"
func main() {
fmt.Println("Hello\nWorld")
}

D. package main
import "fmt"
func main() {
fmt.Print("Hello")
fmt.Print("World")
}

Solution

1. Step 1: Understand printing with new lines

   fmt.Println prints text and adds a newline automatically.

2. Step 2: Check each option's output

   A: Two fmt.Println calls print "Hello" on one line and "World" on the next. Correct.
   B: fmt.Print("Hello\nWorld") prints "Hello\nWorld" (with actual newline) on one line.
   C: fmt.Println("Hello\nWorld") prints "Hello\nWorld" (with actual newline) followed by newline, so output is two lines.
   D: Two fmt.Print calls print "HelloWorld" on one line.

3. Final Answer:

   package main import "fmt" func main() { fmt.Println("Hello") fmt.Println("World") } -> Option B

4. Quick Check:

   Use fmt.Println twice for separate lines [OK]

Hint: Use fmt.Println for each line to print separately [OK]

Common Mistakes:

• Using fmt.Print without newline causes joined output
• Expecting \n inside fmt.Println to create new line
• Confusing fmt.Print and fmt.Println behavior