<\/p>\n
Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n <\/p>\n Run In this lesson we cover Go basic syntax<\/strong> \u2014 the building blocks every Go program shares. If you completed Go Programming \u2013 Setup<\/a>, you already ran your first program. Here we explain why<\/em> that program looks the way it does and the rules you must follow when writing Go code.<\/p>\n Prerequisites:<\/strong> Go 1.22 or newer installed ( Every executable Go program has the same skeleton: a Let us walk through it line by line:<\/p>\n Go source files use the Comments are notes for humans \u2014 the compiler ignores them. Go supports two styles:<\/p>\n Use comments to document your name, the date, and what the program does \u2014 especially in learning exercises.<\/p>\n An identifier<\/strong> is a name you give to a variable, function, type, or package. In Go, identifiers must:<\/p>\n Exported vs unexported:<\/strong> If an identifier starts with an uppercase<\/strong> letter, it is exported (visible outside its package). Lowercase names are private to the package. For example, Valid identifiers: Keywords are reserved by the language \u2014 you cannot use them as identifier names. Go has 25 keywords:<\/p>\n Notice keywords like Unlike Python, Go uses curly braces<\/strong> Every opening brace Go treats extra spaces, blank lines, and tabs mostly as separators \u2014 but style matters for readability. The Go toolchain includes gofmt<\/strong> (or Most editors \u2014 including VS Code with the Go extension and GoLand \u2014 run From the Setup lesson you ran code inside GoLand. From the terminal, inside your project folder:<\/p>\n You now understand Go basic syntax<\/strong>: packages, imports, Continue the series: Lesson 1 \u2013 Introduction<\/a> \u00b7 Lesson 2 \u2013 Setup<\/a><\/p>\n What is the basic structure of a Go program?<\/strong> Does Go require semicolons?<\/strong> What is the difference between go run and go build?<\/strong> <\/p>\nGo 1.22+ Notes<\/h4>\n
go fmt .\/...<\/code> after editing any lesson code. Go 1.22+ uses the same basic syntax shown here \u2014 packages, func main<\/code>, and the standard library remain the foundation for backend and cloud-native projects.<\/p>\n<\/div>\ngo version<\/code> in your terminal). Estimated time:<\/strong> 30\u201340 minutes.<\/p>\n1. Structure of a Go Program<\/h4>\n
package<\/code> declaration, import<\/code> statements, and a main<\/code> function. Consider this program (the same one from the Setup lesson):<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"Welcome to Go!\")\n}\n<\/code><\/pre>\n\n
package main<\/code> \u2014 Declares that this file belongs to the main<\/code> package. Programs that compile to an executable must use package main<\/code>.<\/li>\nimport \"fmt\"<\/code> \u2014 Brings in the fmt<\/code> (formatting) standard library so we can print to the console.<\/li>\nfunc main()<\/code> \u2014 The entry point. Execution starts here when you run the program.<\/li>\nfmt.Println(...)<\/code> \u2014 Calls the Println<\/code> function from fmt<\/code> and prints a line of text.<\/li>\n<\/ul>\n.go<\/code> extension. A small project might live in a single file; larger projects split code across many files in the same package or across multiple packages inside a module (created with go mod init<\/code>).<\/p>\n2. Comments in Go<\/h4>\n
\/\/ This is a single-line comment\n\n\/*\n This is a\n multi-line comment\n*\/\n\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\t\/\/ Print a greeting\n\tfmt.Println(\"Hello, Kindson The Genius!\")\n}\n<\/code><\/pre>\n3. Identifiers and Naming Rules<\/h4>\n
\n
_<\/code>)<\/li>\n$<\/code>, @<\/code>, or spaces<\/li>\n<\/ul>\nPrintln<\/code> is exported from fmt<\/code>; an unexported helper might be named println<\/code>.<\/p>\nname<\/code>, userID<\/code>, _temp<\/code>, MaxRetries<\/code>
\nInvalid identifiers: 2fast<\/code>, user-name<\/code>, go!<\/code><\/p>\n4. Go Reserved Words (Keywords)<\/h4>\n
\n\n
\n \nKeywords<\/th>\n Keywords<\/th>\n Keywords<\/th>\n<\/tr>\n<\/thead>\n \n break<\/code><\/td>\ndefault<\/code><\/td>\nfunc<\/code><\/td>\n<\/tr>\n\n interface<\/code><\/td>\nselect<\/code><\/td>\ncase<\/code><\/td>\n<\/tr>\n\n defer<\/code><\/td>\ngo<\/code><\/td>\nstruct<\/code><\/td>\n<\/tr>\n\n chan<\/code><\/td>\nelse<\/code><\/td>\ngoto<\/code><\/td>\n<\/tr>\n\n map<\/code><\/td>\nswitch<\/code><\/td>\nconst<\/code><\/td>\n<\/tr>\n\n fallthrough<\/code><\/td>\nif<\/code><\/td>\nrange<\/code><\/td>\n<\/tr>\n\n type<\/code><\/td>\ncontinue<\/code><\/td>\nfor<\/code><\/td>\n<\/tr>\n\n import<\/code><\/td>\npackage<\/code><\/td>\nvar<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\ngo<\/code>, defer<\/code>, select<\/code>, and range<\/code> \u2014 they support Go’s concurrency and iteration features you will meet in later lessons.<\/p>\n5. Code Blocks and Braces<\/h4>\n
{ }<\/code> to define blocks of code \u2014 not indentation alone. However, consistent indentation (tabs are standard) makes code readable.<\/p>\nfunc main() {\n\tif true {\n\t\tfmt.Println(\"Inside the if block\")\n\t}\n}\n<\/code><\/pre>\n{<\/code> must have a matching closing brace }<\/code>. Go automatically inserts semicolons at the end of lines during compilation, so you rarely type ;<\/code> yourself \u2014 but statements are still logically terminated.<\/p>\n6. Whitespace and Formatting with gofmt<\/h4>\n
go fmt<\/code>), which formats code to a community standard:<\/p>\ngo fmt main.go\n# or format all files in the current directory:\ngo fmt .\/...\n<\/code><\/pre>\ngofmt<\/code> on save. This is why Go code across projects looks consistent.<\/p>\n7. Running Your Program<\/h4>\n
# Compile and run in one step (great while learning)\ngo run .\n\n# Build an executable binary\ngo build -o myapp .\n.\/myapp\n<\/code><\/pre>\ngo run<\/code> is ideal for quick experiments. go build<\/code> produces a standalone binary you can deploy \u2014 one reason Go is popular for servers and DevOps tools.<\/p>\n8. Next Steps<\/h4>\n
func main<\/code>, comments, identifiers, keywords, and blocks. In the next lesson we cover variables and data types<\/strong> \u2014 how to store and work with values in Go.<\/p>\nFrequently Asked Questions<\/h4>\n
\nA Go program starts with package main<\/code>, imports the packages it needs, and defines func main()<\/code> where execution begins.<\/p>\n
\nGo inserts semicolons automatically at line endings during compilation. You almost never write them manually.<\/p>\n
\ngo run<\/code> compiles and executes immediately without leaving a binary file. go build<\/code> creates an executable you can run or ship separately.<\/p>\n