Get Programming with Go

Overview: This lesson introduces Go, the contemporary programming language of cloud computing. Students will learn the fundamental difference between Go's compiled nature and interpreted languages, how to use the Go Playground for immediate experimentation, and the basic structure of a Go program involving packages and the main function.

Learning Outcomes:

• Define the Go programming language and its primary use cases.
• Explain the role of the Go compiler and its advantages over interpreters.
• Navigate the Go Playground to write, compile, and run code.

Overview: This lesson introduces the fundamental building blocks of Go programming, focusing on how to structure code and control its execution. Students will learn the "one true brace style" and program entry points, progress through variable declaration shortcuts and mathematical operators, and conclude with decision-making logic using Booleans, comparisons, and branching.

Learning Outcomes:

• Correctly structure Go code using the mandatory "one true brace style" to avoid syntax errors.
• Manage data using various variable declaration techniques and arithmetic assignment operators.
• Generate pseudorandom numbers and implement conditional logic using branching and logical operators.

Overview: This lesson explores how Go handles numerical data, ranging from the fractional precision of floating-point numbers to the massive scales required for astronomical distances. Students will learn to manage the limitations of computer memory, including floating-point inaccuracies and integer wrap-around, while mastering explicit type conversion and the use of the big package for "unusual" numeric sizes.

Learning Outcomes:

• Declare and format floating-point variables using float32 and float64 with specific width and precision.
• Identify and mitigate errors caused by floating-point inaccuracies and integer wrap-around.
• Utilize the big package and untyped constants to handle numbers exceeding standard bit-size limits.

Overview: This lesson covers the fundamental building blocks of Go programs: functions, custom types, and methods. Students will learn how to encapsulate logic for reuse, define new types with specific behaviors, and leverage first-class functions—including closures and anonymous functions—to create flexible and modular code. The lesson concludes with a practical capstone project involving temperature conversion tables.

Learning Outcomes:

• Define and invoke functions using parameters, arguments, and variadic syntax.
• Distinguish between exported and unexported identifiers using Go’s naming conventions.
• Create custom types and attach behaviors to them using methods and receivers.

Overview: This lesson covers the essential data structures in Go for managing collections of information. It transitions from fixed-length arrays and their memory-copying behavior to dynamic slices that serve as flexible windows into data, and finally to maps for efficient key-value lookups. The unit culminates in the "Game of Life" capstone, which demonstrates how to use multi-dimensional slices to simulate complex systems.

Learning Outcomes:

• Declare, initialize, and iterate through fixed-length arrays and multi-dimensional grids.
• Manipulate slices using index ranges and dynamic growth via the append function.
• Manage memory efficiency by distinguishing between length and capacity and preallocating collections with make.

Overview: This lesson introduces Go’s approach to organizing complex data and behaviors. Students will learn how to group disparate data types into structures (structs), initialize them using composite literals, and manage their behavior through methods and constructor functions. The lesson also explores Go's unique design philosophy: favoring composition over inheritance and using implicit interfaces to achieve polymorphism.

Learning Outcomes:

• Define, initialize, and copy structures to manage complex Martian coordinate and rover data.
• Encode Go structures into JSON format using struct tags for customized data interchange.
• Implement methods, constructor functions, and struct embedding to build reusable and organized code.

Overview: This lesson explores the power and safety of indirection in Go, focusing on how pointers allow for efficient data mutation and memory management. It provides a robust framework for defensive programming by teaching students how to handle nil values, manage resources with defer, and implement idiomatic error handling patterns—culminating in the application of these rules to a Sudoku validation engine.

Learning Outcomes:

• Use the ampersand (&) and asterisk (*) to manage memory addresses and dereference values.
• Implement pointer parameters and receivers to enable data mutation in functions and methods.
• Navigate nil values across slices, maps, and interfaces without causing runtime panics.

Overview: This lesson introduces the core concurrency primitives in Go: goroutines and channels. It explores how to run tasks independently, communicate safely between them, and manage shared state using Mutexes to avoid race conditions. The lesson concludes with a capstone project simulating Mars rovers navigating a grid and reporting discoveries.

Learning Outcomes:

• Launch and manage concurrent tasks using the go keyword.
• Implement safe communication between goroutines using channels and the select statement.
• Construct data pipelines and manage goroutine lifecycles by closing channels.