Social Icons

Press ESC to close

Learn Go

Categories: Backend, Essentials
Wishlist Share
Share Course
Page Link
Share On Social Media

About Course

Go, or Golang is a fast and efficient programming language built for scalable software development. It’s widely used in cloud-native infrastructure, web development, and operations. With its growing adoption, learning Go equips you to build reliable, high-performance solutions for modern applications.

What Will You Learn?

  • Serve web pages with net/http and route requests with http.HandleFunc.
  • Render HTML safely using html/template, pass structs to templates, and output dynamic values.
  • Collect and validate form input via r.FormValue(...).
  • Build a small interactive page (marquee editor) that updates attributes like scrollamount, scrolldelay, bgcolor, direction, and loop.
  • Use strings.EqualFold and switch to handle case-insensitive options (e.g., directions).
  • Organize a tiny Go web project (modules, file layout) and run it locally on :8080.
  • Add light CSS styling and understand where static assets fit in a Go project.

Course Content

Lesson 1
In this first lesson of the Golang course, we introduce the Go programming language — also known as Golang. You’ll learn about variables and how they are used to store information in memory, as well as the data types that define the kind of values these variables can hold. Go provides strong typing and supports types like integers, floating-point numbers, strings, booleans, and more. We’ll cover how to declare variables using the var keyword, shorthand declarations, and explore the concept of default zero values in Go. You’ll also see how constants differ from variables, and how Go enforces type safety to prevent errors. By the end of this lesson, you’ll have a solid grasp of how data is represented in Go and how to manage it efficiently, setting the foundation for building real-world applications with this modern programming language.

  • Intro & Data Types and Variables
    34:53
  • Quiz 1

Lesson 2
In this lesson we dive deeper into how Go organizes and runs code. We’ll start with the concept of packages. In Go, every program belongs to a package, and the <main> package is where execution begins. You’ll learn how packages help structure code, promote reusability, and keep projects organized. Next, we’ll explore imports. Go lets you bring in standard libraries such as <fmt> for printing, or <os> for working with the operating system. You’ll also see the difference between importing a single library and importing multiple libraries with parentheses. Finally, we’ll practice basic operations in Go, including mathematical operations, string handling, and boolean logic. You’ll see how Go enforces type safety and how operators like +, -, *, /, and % behave. By the end of this lesson, you’ll understand how Go projects are structured, how to import and use libraries, and how to perform common operations that every Go program needs.

Lesson 3
In this lesson, we dive into control flow statements in Go. Control flow allows you to make decisions, branch execution, and loop through code. Unlike some other languages, Go keeps its control structures simple and clean — no parentheses around conditions, and always with braces.

Lesson 4
In this lesson, we explore functions, one of the core building blocks of Go programs. Functions allow you to group reusable blocks of code, making your applications more modular, maintainable, and easier to understand. You’ll learn how to: Define and call functions using the func keyword. Work with parameters and return values, including multiple return values. Understand the difference between value and reference when passing arguments. Use named return values for cleaner code. Write variadic functions that accept a variable number of arguments. Organize code into reusable packages by placing related functions together. By mastering functions, you’ll be able to write Go programs that are both efficient and scalable, while avoiding code repetition. This lesson sets the foundation for more advanced Go topics such as methods, interfaces, and concurrency.

Lesson 5
Build a production-ready REST API in Go using GORM as the ORM and SQLite3 as the embedded database. You’ll scaffold a clean project, wire up database connectivity, and model real entities with GORM struct tags for columns, primary keys, timestamps, and relationships. With routing and JSON handling in place, you’ll implement full CRUD endpoints, return proper HTTP status codes, and add graceful error handling. Beyond the basics, you’ll learn practical API patterns used in microservices: environment-based configuration, health and readiness endpoints, versioned routes, pagination and filtering via query parameters, input validation, and context-aware timeouts. On the data layer you’ll cover auto-migrations, transactions, query building, eager loading, and seeding. The lesson also touches on CORS and logging middleware, testing your endpoints with curl or Postman, and organizing code for maintainability. By the end, you’ll have a small but complete Go service that persists data with SQLite, exposes JSON endpoints, and follows sound API design practices—ready to extend into a larger microservice or deploy as a lightweight backend.

Lesson 6
Learn the core Go collections and text handling you’ll use every day. This session clarifies when to choose fixed-size arrays, how to work effectively with strings (including Unicode), and how to model key–value data with maps. What you’ll get out of it: Arrays: what a fixed-length [N]T actually is, value semantics (copies on assignment), zero values, literals, indexing, iteration with for/range, when arrays are appropriate, and how slices relate to arrays for dynamic sizing. Strings: immutable UTF-8 data, why len counts bytes (not characters), iterating by bytes vs runes, converting between string, []byte, and []rune, and the most useful helpers from the strings and unicode/utf8 packages. Maps: creating with make and literals, the zero-value (nil map) behavior, inserts/reads/deletes, the “comma ok” existence check, iteration order caveats, valid key types, and how maps behave when passed to functions. Gotchas & best practices: avoiding unintended copies with big arrays, safely handling non-ASCII text, initializing nested map/slice structures, guarding maps for concurrent access, and choosing between maps and slices of structs for lookups vs scans. By the end, you’ll be comfortable storing, querying, and transforming data with Go’s arrays, strings, and maps, and you’ll know the pitfalls to avoid as your programs grow.

Lesson 7
Today’s session dives deeper into Go’s type system and its powerful ways of organizing and inspecting data. We’ll cover user-defined types with struct, explore embedded structs for code reuse and composition, introduce interfaces as a way to define behavior, and finally look at reflection (reflect package) to examine types and values at runtime. By the end of this lesson, you’ll understand how to design more flexible, reusable, and introspective Go programs.

Lesson 8
Learn Go’s error-handling model and the control-flow tools that keep programs robust. We’ll cover creating and returning errors with errors.New and fmt.Errorf, wrapping and inspecting errors via errors.Is/errors.As, and designing custom error types. You’ll see where defer shines for guaranteed cleanup (files, locks, transactions), how deferred calls execute in LIFO order, and common pitfalls (captured loop variables, using defer in hot paths). We’ll clarify when a panic is appropriate (truly unrecoverable programmer or invariant violations) versus returning an error, and how to safely regain control with recover inside a deferred function—without abusing it for normal flow. By the end, you’ll structure functions that report rich context, clean up reliably, and fail fast when they must.

Lesson 9
Learn how Go makes concurrent programs simple and safe. You’ll start lightweight tasks with goroutines, connect them using channels, and coordinate work without tangled callbacks. Along the way you’ll handle cancellations, timeouts, and shared data correctly to avoid race conditions and leaks.

Lesson 10
Learn practical file I/O and a minimal HTTP stack in Go. Create, read, write, append, and delete files with os, io, and bufio; manage permissions, paths, and directories; and use defer to close handles safely. Stream large files without loading them fully into memory and serialize data to/from JSON or CSV. Build a small web server with net/http, register handlers and routes, serve static assets with http.FileServer, and implement file uploads/downloads via multipart/form-data. Add request logging and basic middleware, set sensible timeouts, and shut down gracefully with context. Wrap up with security and robustness tips: sanitize paths, limit upload size, check errors, and protect against directory traversal.

Lesson 11
Learn when and how to use import aliases to keep code readable and avoid name clashes, then apply it by building a small command-line number guessing game.

Lesson 12
Learn how to build web pages with Go by combining net/http and html/template. You’ll render dynamic HTML views, pass data into templates, and organize reusable layouts/partials (base, header, footer). You’ll serve static assets (CSS/JS/images), wire simple routes/handlers, and process HTML forms (GET/POST) safely with validation. We’ll cover template functions, escaping to prevent XSS, and clean project structure (handlers, templates, assets). By the end, you’ll have a small multi-page Go web app that renders templates, handles user input, and serves everything from a single Go server.

Student Ratings & Reviews

No Review Yet
No Review Yet

Join to our community 👋

Unlock full access to my Tutorials and see the entire library of members only posts.

Subscribe to our Newsletter, cancel at anytime.

Join Now