(Golang) Go Projects for Non-Go Engineers: With AI Assistant

The course covers Go fundamentals, installation, and development methodology, including optional use of GitHub Copilot as an AI assistant. Students will learn Go-specific syntax, unit testing, JSON handling, data structures, pointers, functions, OOP in Go, and third-party libraries. Real-world projects include building a stock application, REST APIs, and working with PostgreSQL. Advanced topics include dependency injection, error handling, concurrency, generics, middleware, and an introduction to Protocol Buffers and GRPC.

Explore the origins, purpose, and unique features of the Go programming language. Compare Go to established languages like Java, C#, and Python, and understand its advantages in backend development and cloud integration. Gain insight into Go’s syntax, compiled nature, and strong concurrency support, making it a powerful tool for scalable, modern systems.

Learn Go through a hands-on, project-based approach designed for busy learners. Build progressively challenging projects with guided challenges, hints, and full solutions. Gain practical experience in writing Go code, solving real-world tasks, and incorporating unit testing. Each task promotes independent problem-solving and optionally explores AI-assisted coding using GitHub Copilot. Projects are concise yet rewarding, with clear explanations and downloadable resources.

Explore how AI tools like GitHub Copilot and ChatGPT can support Go development. Learn when and how to use GitHub Copilot effectively while understanding its capabilities and limitations. AI use is entirely optional—core programming concepts remain the focus. Dedicated sections provide insight into AI integration in software engineering, offering a modern, flexible learning experience.

Uses AI assistants to enhance learning, but emphasizes critical thinking and validation of AI-generated code. AI responses may differ each time, even with the same prompt. You’ll gain experience using GitHub Copilot in Visual Studio Code, with awareness of its limitations and potential. The course encourages a healthy skepticism and reinforces that AI is a tool to assist—not replace—your decision-making as a developer.

Explore how AI assistants like ChatGPT and GitHub Copilot transform the way we write, understand, and debug code. We’ll use simple prompts in plain English to generate Python, Java, and Go applications, examine syntax basics, and identify common coding errors. By leveraging AI, we simplify complex programming concepts and speed up our learning process—without relying heavily on traditional searches or memorizing rules.

Discover how AI tools like ChatGPT and GitHub Copilot revolutionize software engineering and testing. We explore their unique strengths—ChatGPT’s natural language understanding and documentation support, alongside Copilot’s real-time code generation and debugging assistance. Learn how to integrate these tools effectively.

We explore easy access to ChatGPT without installation, using both free and paid versions. We set up a GitHub account essential for GitHub Copilot, while working across Windows, Mac, or Linux. Using Visual Studio Code, a versatile and free programming environment, we integrate GitHub Copilot smoothly. Practical steps guide us through registration, login, and software setup to start leveraging these powerful AI tools effectively.

We manage Go dependencies with modules and set up a project folder to organize code efficiently. We create a Go file, define the main package, and import essential libraries like fmt for output. Writing the main() function serves as the application entry point, displaying "Hello universe!" in the terminal.

We create a greet function returning a fixed string and call it in main, using Go’s concise variable declaration. Then, we write a unit test following Go’s conventions, comparing expected and actual values to ensure correctness. The testing framework flags failures with clear messages. Running and debugging tests directly in Visual Studio Code streamlines validation, helping us confidently verify code functionality with practical testing techniques.

We enhance the greet function by adding a language code parameter to customize greetings internationally. Using Go’s strings package, we handle case-insensitive comparisons and format dynamic messages. Multiple unit tests cover different languages, ensuring accurate outputs. Running tests highlights any failures, helping us quickly fix issues. Finally, running the main application demonstrates real-time multilingual greetings.

We simplify multilingual greetings by replacing lengthy if-else chains with Go’s clean switch/case/default statements. This approach makes the code more readable and efficient, with implicit breaks between cases. Adding new languages like Italian and Swedish becomes straightforward. Unit tests verify each case, and running the main function confirms the correct greeting displays.

We explore Go maps by defining key-value pairs, initializing elements, and accessing items with multi-value returns. We practice checking for key existence using boolean results and handle missing keys gracefully. The session highlights Go’s concise syntax for map lookups and conditional handling.

We design and run unit tests using custom structs to organize test names, inputs, and expected outputs. The session guides us through looping test cases with subtests, comparing actual results to expectations, and handling failures with clear error reporting. We also practice intentionally failing tests to understand Go’s feedback and ensure reliable, maintainable code.

We dive into Go packages, exploring how they organize source files, control scope, and manage visibility through naming conventions. We learn to create, import, and use packages effectively, understand public vs. package-level access, and apply best practices for naming and structuring code to build modular, maintainable Go applications.

We ensure proper resource management by using Go’s defer keyword to postpone cleanup actions until a function finishes. This approach prevents leaks by closing resources reliably, even when errors occur. We explore defer’s last-in-first-out execution order and practice placing cleanup statements close to resource acquisition for safer, clearer code.

Set up a new Go project for handling movie watcher data. We will define Go structs that precisely mirror our JSON data structure, using field tags to map PascalCase variable names to the required lower kebab-case JSON fields. We will then build a function to load the information from the JSON file into our structs.

We build a Go project from scratch, creating modules, defining data structures to represent watchers and movies, and loading JSON data efficiently. Together, we explore struct tags, slices, third-party packages, and error handling, then format and display JSON output for clear insights into user movie-watching data.

Learn how to build robust unit tests for our file-loading function. We will create a test file and write table-driven tests to cover multiple scenarios, including reading a valid file, a non-existent file, and a corrupted JSON file. We will use reflect.DeepEqual to compare results and confirm our error handling works correctly.

We explore Go’s zero values and nil, revealing how variables initialize by default without explicit assignments. Together, we learn to handle slices, maps, and structs safely using the make function, prevent runtime errors, and understand how Go manages uninitialized states to write robust, error-free programs.

Enhance our application to analyze movie data. We will build functions to normalize movie titles, use maps to track movie popularity, and find the most-watched films. We will also implement a custom sorting function using sort.Slice and an anonymous function to organize movies first by title and then by release year.

Build a function to check for the existence of an object within a Go slice, a common task that lacks a built-in method. We will implement a case-insensitive search for a watcher by either username or email. Our main application will then use this function to prevent adding duplicate watchers to the slice.

Focus on persisting our data. We will create a function to save our slice of watchers back into a neatly formatted JSON file. We'll explore how to improve performance by using a buffered writer for more efficient file I/O and ensure data integrity by flushing the buffer upon completion.

Tackle the challenge of combining two lists of data while avoiding duplicates. We will build a function that merges two slices of watchers into a single, unique list by leveraging a map for efficiency. We will also write a clever unit test that validates our result even when the element order is random.

Explore how Go handles function parameters by value and discover why this can prevent functions from modifying original variables. We will learn to use pointers to pass data by reference, allowing our functions to alter the original data directly, and understand how even pointers are passed by value.

We will build an application to track aircraft mileage. We'll define an Aircraft struct and create an AddMileage function that uses a pointer to modify the original aircraft instance directly. We will also write comprehensive unit tests to ensure our mileage calculations are always accurate and reliable.

We will enhance our aircraft tracking system by linking aircraft to airlines using pointers. This demonstrates how multiple aircraft can share and reflect real-time updates from a single airline object. We will write unit tests to confirm that changing an airline's details correctly updates all associated aircraft records simultaneously.

Discover the power of functions as first-class citizens in Go. We will assign functions to variables , pass them as arguments to other functions , and even return them from functions. This opens up advanced patterns like table-driven tests with custom validation logic for each test case.

We will build an efficient, in-memory distance cache by loading data from a JSON file. We will implement a WingCache struct using nested maps for quick lookups and create functions to populate it. We'll also see why passing pointers is crucial for performance, especially with large data structures.

Let's advance our caching system by building a function that reads all JSON files from a directory and merges them into one master cache. We will use a variadic function to accept any number of caches , learning to use the ... syntax to unpack a slice into individual arguments.

We will build a fully interactive command-line application. We'll learn to read and process user input to create a flight simulator game. The application will use our distance cache to track an aircraft's journey, continuously updating its mileage as it flies from one user-specified destination to the next.