Go Bootcamp: With gRPC and Protocol Buffers (HTTP/S, HTTP2)

Explore version control concepts and git, created by Linus Torvalds, a distributed system that tracks changes, enables branching, and supports collaboration with backups to revert.

Update your Linux system with apt update, install Git, verify with git --version, and optionally upgrade Git to the latest version.

Install Git on Windows to streamline version control for Go projects, with focus on setup steps, configuration, and basic workflows.

Explore GitHub, a cloud platform built around git that enhances version control, collaboration, and remote hosting, with steps to create repositories.

Configure local git with global user name and email, add SSH keys for authentication and signing commits, and use a private GitHub email. Test SSH to enable push without prompts.

Initialize your project with git init to enable tracking in the dot git folder and learn to set the default branch to main and rename branches with git branch -m.

Open your project in your editor and run git status to see untracked changes. Use git add to move changes to the staging area, then commit to record them.

Commit staged changes with git commit -m 'your message', review with git status and git log, and push to a remote GitHub repository to link your local and cloud repos.

Connect your local Go project to a remote repository by adding a remote named origin, using ssh or https links, and push changes to GitHub.

Push local changes to the remote with git push -u origin root or main. This establishes a permanent uplink and keeps the local branch in sync with origin.

Set up your learning environment by creating a directory named go course, initializing a git repo, and connecting the local repo to the SSH link of the GitHub remote.

Write and run a simple Go program with package main and func main, import fmt, print hello world, then use go run hello.go to execute the binary.

Learn why go run compiles and executes a program in one step, creating a temporary in-memory executable, and how it differs from go build for development and testing.

The go compiler translates code to machine code, while the go runtime manages memory with garbage collection and schedules go routines for concurrency.

Explore the Go standard library, a collection of packages included with every Go installation, and learn how to import packages like fmt to access input/output, networking, concurrency, and cryptography.

Learn how Go import statements bring external libraries into code, control final executable size with selective imports and tree shaking, and use named imports for cleaner, faster programs.

Explore Go data types defining variables, including integers, floating point numbers, complex numbers, booleans, strings, and composite types like arrays, slices, maps, and structs, plus zero values.

Learn Go variables, covering var declarations, the short variable declaration syntax (:=), type inference, and default values, plus local versus global scope and meaningful naming for readable, maintainable code.

Learn Go naming conventions, using Pascal case for types, snake case for variables and files, and all caps for constants, with emphasis on descriptive, consistent identifiers and readability.

Learn how to declare and use constants in Go, exploring uppercase and lowercase conventions, typed and untyped constants, and const blocks for immutable values that improve clarity and maintainability.

Explore Go arithmetic operators, including addition, subtraction, multiplication, division, and modulus, and master operator precedence with practical int and float examples, plus overflow and underflow concepts.

Master Go for loops to iterate numbers and collections with initialization, condition, and post expressions, using break and continue to control flow. Explore range over integers and slices.

Discover how the Go for loop acts as a while loop by omitting initialization and post statements, enabling break and continue within a guessing game with user input.

Explore the core operators, focusing on logical not, or, and, bitwise variants, and apply comparison operators like ==, !=, <, <=, >, >= in practical code.

Master Go conditional statements, including if, else if, and else, to control program flow. Use nesting and logical operators to handle age checks, temperature, and scores.

Discover how Go switch statements evaluate a single expression against multiple cases, use default handling and implicit breaks, and apply type switches for interface values to replace long if-else chains.

Master Go arrays: fixed size, value types, zero initialized, index-based updates, for and range iterations, len for length, multi-dimensional arrays, and the blank identifier for unused values.

Discover Go slices as dynamic views into arrays, including declaration, creation with make, appending, copying, and nil slices. Learn slicing, two-dimensional slices, and the capacity-length relationship for efficient data handling.

Explore how maps store key-value pairs with unique keys, declare and initialize via make or literals, manipulate, check existence, delete, clear, iterate, and nest maps for configuration data.

Explore how the range keyword in Go enables efficient iteration over arrays, slices, strings, maps, and channels without explicit indices, and how the blank identifier prevents memory leaks.

Explore Go functions as fundamental building blocks that promote modularity and code reuse. Learn declaration with func, parameters, return types, multiple returns, closures, and treating functions as first-class citizens.

Explore how Go functions return multiple values, enhancing error handling and data extraction, with practical divide examples and named return values for clearer code.

Explore variadic functions in Go, learn how to declare variadic parameters with an ellipsis, compute sums, combine with regular parameters, and pass slices using the ellipsis to unpack arguments.

Learn how the defer statement postpones execution until the surrounding function returns, enabling reliable cleanup. Understand immediate argument evaluation, LIFO execution, and practical uses in go routines and APIs.

Learn how the panic function halts execution, unwinds the stack, and runs deferred cleanup, signaling an unrecoverable error in Go, with any type via interface.

Learn how recover, used with defer, regains control of panicking go routines, allowing programs to continue and log panics for graceful error handling.

Explore how Go's os.Exit terminates a program immediately with a status code, bypassing defer and cleanup, and learn best practices for meaningful non-zero codes and how zero indicates success.

Master the go init function, a no-argument, no-return special function that runs once per package before main. It initializes variables, configurations, and components in declaration order.

Solidify your Go programming foundation by revisiting syntax, compiler basics, packages, data types, variables, and core control flow. Stay motivated with a self-paced approach and engage with the community.

Discover how closures in Go capture variables from outer scope using lexical scoping, enabling stateful functions and first-class function behavior. See practical examples and notes on memory and concurrency.

Explore recursion in go, including base and recursive cases with factorial and sum of digits. Learn its uses in algorithms and data structures, and note performance and memoization considerations.

learn how pointers store memory addresses, enable dereferencing, and modify values for efficient data handling in Go and gRPC with protocol buffers, including nil pointers.

Explore strings and runes in Go, including string literals, escape sequences, length, indexing, and concatenation, and master Unicode handling with runes and international text.

Explore Go printf formatting verbs, including general verbs, numeric bases, string and boolean outputs, with practical examples of width, alignment, padding, and Go syntax representation.

Master the fmt package in Go for printing, formatting, and scanning, with examples of print, println, printf, sprint, sprintln, scan, scanf, and scanln, plus errorf for formatted errors.

Explore go structs as lightweight composite types with fields, initialization via literals, and dot notation access; learn methods, pointer receivers, embedding, anonymous structs, anonymous fields, and struct comparison.

Discover how Go methods attach to types, using value and pointer receivers, and how embedding promotes rectangle methods to outer types.

Explore how Go interfaces define behaviors to enable polymorphism and decoupling, with examples of geometry shapes implementing area and perimeter and using interfaces as function parameters.

Discover struct embedding in Go by embedding a person into an employee to promote fields and methods, access fields directly, override methods, and compare anonymous versus named fields.

Learn how Go generics use type parameters to write reusable, type-safe functions and data structures, exploring a generic stack with push, pop, and is empty for multiple types.

Explore Go errors by using the built-in error interface, errors.new, and custom error types; learn idiomatic error handling, propagation, and descriptive messages with fmt errorf.

Master custom errors in Go, including error types with codes and messages. Implement wrapped errors and robust error handling in APIs and gRPC endpoints.

Master go string manipulation: measure length, concatenate, slice, access ascii values, and use split, join, contains, replace, trim, case changes, count, prefix, suffix, regex, utf-8 counts, and strings.Builder for efficiency.

Explore string formatting in go using the fmt package, format specifiers, and string interpolation, including width, padding, alignment, raw string literals with backticks, and practical examples.

Go text templates let you define dynamic output by parsing templates, inserting data with dot notation, and applying conditional and loop actions, using text/template or html/template with template data.

Explore regular expressions in Go, including compiling patterns, capturing groups, replacements, and flags, with practical examples for validating emails and parsing dates.

Explore the Go time package to create, parse, format, and compare times; handle durations, add or subtract time, and work with time zones and location conversions.

Master epoch time and the Unix epoch, defined as 00:00:00 UTC on January 1, 1970, and explore Go's time package for converting, formatting, and handling seconds and milliseconds.

Learn to format and parse time in Go using the time package, including layout patterns, ISO 8601 parsing, Unix timestamps, and robust error handling for time zone aware applications.

Explore how Go's math/rand generates pseudo random numbers, seed concepts, and range handling, illustrated with a dice game and guidance on when to use crypto/rand.

Explore number parsing in Go using the string conversion package to parse integers and floats, including binary and hex formats with base and bit-size options and robust error handling.

Learn how to parse and build urls in Go with the net/url package, extracting scheme, host, path, query parameters, and fragment, then encoding query values for robust web tasks.

Explore the Go buff io package for buffered input and output, wrapping io.reader and io.writer to boost performance with read, read string, write, write string, and flush.

Explore base64 encoding in go, covering binary-to-text encoding, encoding and decoding with the encoding/base64 package, url safe variants, and practical examples.

Explore hashing with sha-256 and sha-512, including salts and base64 encoding in Go, to securely store and verify passwords, ensure data integrity, and understand deterministic outputs and the avalanche effect.

Learn to create and open files with Go's os package, write data using write and write string, handle errors, and ensure cleanup with defer close.

Open files with the os package, defer closing, and read contents as bytes or lines using bufio.Scanner. Handle read errors and end-of-file conditions to ensure safe file I/O.

Learn to implement line filters in go by reading text line by line, filtering by keywords or length, removing empty lines, and transforming case, with practical examples and error handling.

Master Go file paths by using the file path package to join, clean, split, and derive absolute or relative paths, while creating directories and validating user input for security.

Master directory operations in Go using the os and path/filepath packages to create, read, navigate, and delete folders with proper error handling and permissions.

Learn how to create, manage, and clean up temporary files and directories in Go using os.CreateTemp and os.MkdirTemp, with best practices for isolation, unique naming, and prompt removal.

Embed static files and directories into go binaries at build time using the go:embed directive, simplifying deployment and enhancing security by bundling assets inside the executable.

Explore how Go handles command line arguments with os.Args and the flag package, including printing args, using flags with - and --, defaults, and parsing inputs.

Explore how to design and configure subcommands in a Go command line tool, using flag sets, flags, parsing, and error handling to create modular, help-ready CLI applications.

Access, set, and unset environment variables in Go using the OS package, listing keys and values and demonstrating split; follow security, naming, and cross-platform best practices.

Explore Go logging fundamentals from the standard log package to custom loggers, prefixes, and flags, then compare third-party options like logrus and zap for structured JSON outputs and file logging.

Explore how to encode and decode json in Go using encoding/json, marshal, unmarshal, and struct tags, including nesting, omitempty, and handling unknown structures.

Learn how struct tags govern JSON encoding and decoding. Map fields to JSON keys, omit empty with omitempty or omit using a hyphen, and apply db and XML tags.

Explore encoding and decoding XML in Go with the encoding/xml package, focusing on marshal and unmarshal, root element naming, struct tags, attributes, and nested structs.

Explore how the Go extension for VS Code provides diagnostics, linting, formatting, and navigation via gopls. See how it aligns with the Go compiler and offers IntelliSense and pre-compilation checks.

Master Go type conversions, converting numeric types like int32 and float64, and strings to byte slices. Learn which type pairs are compatible and how truncation affects precision.

Explore the Go io package, mastering core interfaces like io.Reader, io.Writer, and io.Closer, and learn to read, write, pipe data, and manage resources with buffers and files.

Explore the Go math package constants and functions, including pi, e, phi, sqrt, abs, pow, exp, log, trig and inverse trig, rounding, and handling NaN and INF.

Advance into the Go bootcamp's challenging topics by reviewing source code, building your own examples, and actively engaging in Q&A to reinforce discipline and perseverance.

Explore how goroutines enable non-blocking, concurrent execution in Go, managed by the go runtime scheduler with an m:n model that multiplexes goroutines onto OS threads for scalable parallelism.

Explore channels and goroutines to enable safe data exchange and execution, using make to create channels and the send and receive operators to pass values, while understanding blocking and deadlock.

Explore unbuffered and buffered channels in Go, learning how buffers provide storage for asynchronous communication, prevent blocking, and improve data flow, load balancing, and concurrency between producers and consumers.

Explore how buffered channels enable asynchronous data storage and flow control by holding values up to a capacity, letting producers and consumers decouple and manage concurrency.

Explore channel synchronization to coordinate goroutines with unbuffered and buffered channels, ensuring safe data exchange, preventing race conditions, and applying to chat apps, stock feeds, and real-time news streams.

Channel directions define send or receive usage in functions and goroutines to improve clarity and safety; unidirectional channels arise from the arrow operator, while bidirectional channels power producers and consumers.

Master multiplexing in Go by using the select statement to wait on multiple channel operations, handle timeouts and cancellations, and coordinate goroutines with default case support.

Explore non-blocking channel operations in Go, using select with default for non-blocking receive and send, and manage data and quit channels to optimize concurrency.

Close channels to signal completion and prevent resource leaks; call the close function, close only from the sender and exactly once, using producer and filter patterns in a pipeline.

Explore how context manages deadlines, cancellation signals, and request-scoped values in Go with examples of background and todo contexts, timeouts, and key-value pairs.

Master Go timers to implement timeouts, delays, and periodic tasks. Explore non-blocking timers, time.After, timer.Stop, timer.Reset, and channel-based patterns for efficient, responsive applications.

Master tickers in Go by using the time package to create a new ticker that triggers periodic tasks like polling, logging, and updates, with stop and defer for graceful shutdown.

Explore worker pools in go routines, task queues, and workers to scale concurrent processing with graceful shutdown and real-world ticket processing examples.

Explore how wait groups synchronize Go routines in Go with add, done, and wait, enabling concurrent tasks to finish before proceeding and ensuring graceful cleanup.

Explore how mutexes in Go provide mutual exclusion to protect shared resources, prevent race conditions, and coordinate access to critical sections using the sync package.

Leverage atomic counters to safely update shared values in Go concurrency, using the sync/atomic package to perform indivisible operations and prevent data races in goroutines.

Explore rate limiting to control traffic and protect resources, ensuring fair usage and cost management. Implement token bucket, leaky bucket, and fixed window counter algorithms with practical Go examples.

Implement a token bucket rate limiter in Go with a buffered tokens channel and a refill timer to enforce a five requests per second limit.

Master the fixed window rate limiting algorithm, dividing time into equal windows and enforcing a fixed request limit with a reset at each boundary. Compare it to token bucket.

learn the leaky bucket rate limiting algorithm, its processing rate and token management, and how it handles concurrent requests with comparisons to token bucket and fixed window and practical uses.

Explore how stateful goroutines maintain and update internal state across executions, using channels, mutexes, and atomic operations for safe concurrency. Learn lifecycle management, practical patterns, and a counter example.

Explore testing and benchmarking in go using the built-in testing package, write table-driven and subtests, run benchmarks, and profile performance with pprof.

Explore spawning operating system processes in Go using the os/exec package, including running commands, handling input and output, and managing concurrency, isolation, and subprocesses.

Explore Go signals with the os/signal package to handle sigint and sigterm for graceful shutdown, resource cleanup, and inter-process communication via channels and goroutines.

Explore the Go reflect package to inspect and manipulate types and values at runtime, enabling dynamic behavior, serialization and deserialization, and calling methods for generic programming.

Celebrate completing the advanced Go section and solidify your foundation in Go, routines, channels, and synchronization, building confidence to tackle more challenging topics with independent problem solving.

Demystifies concurrency and parallelism in Go, showing how goroutines and wait groups enable concurrent and parallel execution across cores, guided by the Go runtime scheduler.

Detect race conditions and data races in go programs with the race detector using go run -race, then fix them with mutexes, atomic operations, and reduced shared state.

Explore how deadlocks arise in concurrent go programs, driven by mutual exclusion, hold and wait, no preemption, and circular wait, and prevent them with consistent lock ordering.

Learn how the RW mutex lets multiple readers hold a read lock while ensuring exclusive access for a writer, optimizing read-heavy shared data.

Explore the sync.NewCond condition variable and its integration with a mutex. Learn the wait, signal, and broadcast methods through a producer-consumer example, with Go synchronization best practices.

Explore the sync.Once construct to guarantee a function runs only once across concurrent goroutines. See how do prevents repeated initialization with an initialize function and a wait group.

Explore how Go's sync.Pool provides a pool of reusable objects to reduce allocations and garbage collection, using Get, Put, and an optional new function.

Explore the for select pattern in Go to handle multiple channels, using a ticker and a quit channel to print ticks and gracefully quit.

Explore how the internet works, including DNS resolution, TCP handshakes, and HTTP requests, highlighting URL and URI components like host, path, and query.

Explore the request-response cycle, detailing how a client and server interact via http/https, methods, headers, dns resolution, and status codes for web APIs.

Explore the front end, or client side, of a web app by designing user interfaces, handling interactions, and presenting data from the back end using HTML, CSS, and JavaScript.

Master back end fundamentals by building server side logic, processing requests, and managing data across databases and APIs, including http interactions with the front end.

Trace evolution of HTTP from 1.0 to 3, highlighting persistent connections, chunked transfers, and headers in 1.1, multiplexing and header compression in 2, and QUIC-based, encrypted 3 with zero rtt.

Opt for Linux as the development OS when building Go APIs, using benchmarking and request–response tools; on Windows, enable WSL to access Linux-only tools.

Explore how rest principles enable stateless, resource based apis using endpoints and urls with http verbs like get, post, put, patch, delete, with requests and responses, caching, and real-time considerations.

Explore api endpoints, including base urls, paths, query parameters, and http methods, and understand resource, action-based, and query-based endpoints with versioning and error handling.

Use the go http package to create an http client, send get requests, and handle responses. Focus on building a server and api, explore json placeholder and star wars api.

Learn to build http servers in go using the net/http package by defining handlers, configuring routes, and listening on localhost ports such as 3000 or 8080.

Understand how ports function as dedicated doors for network traffic, from well known, registered, and dynamic ranges, enabling web servers, APIs, and local apps to reach the outside world.

Explore API testing with Postman, including gRPC support, from installation to sending requests and viewing organized responses, plus testing public APIs like Star Wars API and JSON placeholder.

Install wrk, a versatile benchmarking tool, on macOS via Homebrew, on Windows using WSL, or on Linux with apt, to benchmark servers and analyze performance metrics.

Learn how to monitor system resources with htop, compare it to built-in task managers across Windows, macOS, and Linux, and install htop on macOS via brew or on WSL.

Benchmark a Go API against Node.js frameworks to see Go’s default multicore utilization and high throughput. Learn how Express.js, Fastify, and pure Node.js affect CPU usage and requests per second.

Master go modules and go mod init to create go.mod, manage external dependencies, and build stable, versioned code with go mod tidy and go get.

Build a simple Go API server on port 3000 with routes for orders and users, handling all HTTP methods. Demonstrate startup confirmation and basic request handling.

Explore how go get manages third party packages, their dependencies, and go.mod updates, go mod tidy, and how module storage and go list reveal dependencies.

Create a Go server that supports http two and http 1.1 over http https with fallback, using self-signed certificates for development, configuring TLS min version 1.2, and testing with Postman.

Learn how pem key and cert files enable https and tls, including private keys, public keys, and certificates, with common name and issuer, plus renewal basics.

Test your api with Postman over https, compare http/1.x and http/2, and observe TLS handshake behavior with a self-signed certificate. Understand TLS certificate verification differences between browsers and Postman.

Learn to use curl for HTTP/2 testing, observe HTTP version and TLS negotiation, and handle self-signed certificates with -k while comparing curl with Postman for API testing.

Learn how http/2, https, and http connections differ, how gRPC relies on http/2 over tls, and the TLS handshake and session keys that secure them.

Explore mutual TLS integration with Postman, enabling SSL certificate validation, using CA certificates, client certificates, and OpenSSL configuration to secure Go API communications.

Benchmark http/1.1 with tls, http/2 with and without tls using h2load to compare overhead, traffic, and throughput, noting http/1.1 can outperform http/2 locally while http/2's header compression reduces traffic.

Explore Go's json marshal and unmarshal functions, and use json.NewDecoder and json.NewEncoder for streaming and large datasets, with practical in-memory examples.

Plan and organize an API project by outlining a scalable folder structure (project root, cmd, internal, models, repository, pkg, proto) and define environment handling, routing, and data access.

Plan and design a scalable school management API by translating requirements into modular endpoints for executives, students, and teachers, with login, JWT authentication, rate limiting, and bulk operations.

Build a Go API project, configure a cmd server, create routes, and implement CRUD operations with HTTP methods using switch-case in a RESTful design.

Learn to process client input in Go by parsing URL-encoded forms and raw JSON bodies, handle errors, and unmarshal JSON into structs or maps for API processing.

Master path parameters in go using the standard library, exploring legacy methods and go 1.22 improvements to extract ids from urls for modular rest apis.

Learn to use query parameters for filtering and sorting in get requests, separate from path parameters. Extract them in Go with r.URL.Query; apply defaults when missing.

Initialize a git repository in your project root, switch to main, and create a dot gitignore to ignore sensitive files and folders, safeguarding secrets before pushing to remote repos.

Discover how go mux, a request multiplexer, routes HTTP requests to handlers by URL and method, efficiently and maintainably. Learn to initialize with http.NewServeMux and apply middleware across routes.

Explore Go middleware as gatekeeping wrappers that process requests and responses. Chain multiple middleware using next to apply logging, authentication, authorization, data validation, and error handling before the final handler.

Create and apply security headers middleware for a Go REST API, setting x dns prefetch control, x frame options, xss protection, no sniff, hsts, content security policy, and referrer policy.

Explore cross-origin resource sharing and implement a go middleware to restrict access by origin, configure allowed origins, handle preflight requests, and set security headers.

Implement a response time middleware in Go to measure API latency by wrapping the http.ResponseWriter, capturing status codes, and logging endpoint performance with an x response time header.

Explore how to implement compression middleware in Go to reduce response sizes, improve loading times, and lower bandwidth costs by negotiating content encoding with the client via the accept-encoding header.

Develop a customizable rate limiter middleware in go that enforces per IP requests per minute using a mutex and visitor counts, resetting after each duration to create a rolling window.

Design and implement an HTTP parameter pollution (hpp) middleware in Go that cleans query and body parameters, enforces a whitelist, and supports first or last value handling for duplicates.

Learn the correct ordering of middlewares in a Go API, including rate limiter, cors, security headers, compression, and response time, and watch the request flow via debug prints.

Create applyMiddlewares to chain middlewares around an http handler using a variadic type. Apply them to the mux in order, with hpe options, compression, security headers, and rate limiting.

Explore the older routing technique used before go 1.22 to work with legacy codebases. Prepare to upgrade to go 1.22 features in upcoming lectures.

Implement a Get method for teachers in a Go API, using an in-memory map with init data, supporting all, filtered, and single-entry retrieval via path and query parameters, returning JSON.

Add a post handler to create one or more teachers using JSON decoding, a mutex, and in-memory storage, then return a JSON response with added teachers and a created status.

Refactor a Go API by splitting handlers into teachers, students, and execs, moving the teacher model to models, exporting routes, and building a router to improve readability.

Explore MariaDB as a free, open source RDBMS compatible with MySQL, offering a drop-in replacement, diverse storage engines, SQL support, security features, and scalable replication and clustering.

Learn how to install MariaDB on Linux using apt, install server and client, secure installation by setting root password, remove anonymous users, disable remote root login, and verify service status.

Explore how to install and use DBeaver and phpMyAdmin to manage MariaDB and MySQL databases across Windows, macOS, and Linux, including creating connections, testing drivers, and checking firewall and permissions.

Learn to perform CRUD operations in MariaDB via the command line, including creating databases and tables, inserting, querying, updating, and deleting records, with a preview of DBeaver.

Learn how to perform CRUD operations in MariaDB/MySQL using DBeaver, including creating databases and tables, defining primary keys and auto increment, and executing SQL via GUI and SQL editor.

Connect your API to a MySQL or MariaDB database by creating a SQL config, handling the connection string, registering the MySQL driver, and testing with a sample database.

Explore how the dot env file stores environment variables for API and web servers, including database credentials, API keys, and ports, and load them securely across development, testing, and production.

Create a school database and a teachers table with id auto increment starting from 100, first name, last name, email (unique), class, and subject, and index email.

Update post methods to store teachers in the database, inserting first name, last name, email, class, and subject, and using last insert id to return a json response.

Modify the get teacher's handler to fetch a single entry by id from the database using a select query, scan results, and handle not found (404) errors.

Modify the get teachers handler to return multiple teachers by querying the database with optional first and last name filters, building a teachers list from results.

Understand how where one equals one acts as a dynamic placeholder to build flexible, multi-filter queries in go, using and to add conditions across any column.

Extend the Go API by enabling dynamic filtering on any field with a param map, refactor into an add_filters function for cleaner code, and prepare for sorting options.

Learn to implement multi-criteria sorting for API GET requests in Go, validating fields and orders, parsing query parameters, and refactoring into a reusable addSorting function.

implement the put method to fully replace a teacher entry by extracting the id from the url, decoding the request body, and updating the database, contrasting put with patch.

Explore implementing a Go patch handler that updates only provided fields for a teacher record by decoding request data into a map and applying selective field updates in the database.

Master patch handling in Go by using the reflect package to update many struct fields via json tags, with type-safe setting and field iteration.

Implement the delete operation for a teacher in a Go REST API, using db.exec to run delete from teachers where id, handle errors and rows affected, and return HTTP responses.

Practice modern routing in go 1.22 by switching to method-based routing, extracting path parameters, and wildcard patterns, replacing manual method checks with route-aware handlers, and updating go.mod.

Refactor the router to adopt the modern mechanism in Go, implementing get, post, put, patch, and delete for the teachers route and proper path parameter handling.

Learn to use path parameters to fetch a single teacher, refactor the get logic into distinct single and multiple handlers, and map the path id to a database lookup.

Implement a patch teachers handler to update multiple entries atomically using a transaction, decoding a list of updates by id, applying changes with reflection, skipping id field, and handling errors.

Develop a delete multiple teachers endpoint using a transaction, decoding id arrays, executing a prepared delete per id, and returning the deleted ids in json.

Explore how data modeling uses struct-based models to represent and validate API data with JSON, XML, and db tags in a model package that abstracts database access from application logic.

Refactor the teacher handlers by extracting database operations into a dedicated sql connect package, creating modular, readable code with improved error handling and maintainable CRUD operations.

Implement a centralized error handling mechanism for all api functions by creating a utils error handler, a custom logger, and integrating it across crud and route layers.

Show how to use database tags and reflection to map struct fields to columns and generate insert queries, with or without an ORM like gorm.

Apply data validation to APIs by checking format, presence, type, range, and length to protect integrity and security, guarding against SQL injection and XSS with server-side validation and meaningful errors.

Create the students table and relate it to the teachers table via class to enable CRUD and class-based queries; index the teachers class column to fix foreign key issues.

Demonstrates building a students route with get handlers, crud operations, and shared utilities by renaming models, implementing sorting and filters, and testing the student API.

Test the students routes in a Go API by validating CRUD operations and foreign key constraints, using Postman and database checks to ensure class teacher existence.

Add two new subroutes to the teachers handler to fetch each class teacher's student list and student count via get requests under teachers/{id}/students and teachers/{id}/studentcount, avoiding nil handlers.

Get the list of students for a teacher by ID, query the database, and return a json response with status, count, and data, while handling errors and refactoring db access.

Create a dedicated student count endpoint by teacher id, using an sql count with a subquery to determine the class, enabling efficient single-value responses.

Refactor the go router by extracting related routes into separate files and creating teachers and students routers as sub routers. Assemble them with a main router using http mux.

Refactor the Go router to support execs with an http server and mux, implementing login, logout, forgot/reset password, and update password routes, including user id path parameters.

Create the execs user model and table with auto increment primary key on id, include email, username, password, and role, and support nullable fields with indexes on email and username.

Implement full crud for execs in a go application, covering get, get one, add, update, and delete routes, with json and db tags and refreshed queries.

This lecture implements secure password hashing for an enterprise api using Argon2id with a salt and base64 encoding, storing the hash instead of plaintext.

Verify user identities with credentials, tokens or JWTs and, when authenticated, determine access using RBAC, ABAC, or ACLs. Apply least privilege and regular audits to secure APIs.

Explore cookies, sessions, and jwt, showing how cookies hold session IDs and user preferences, how server-side sessions persist data, and how jwt enables stateless authentication for rest apis.

Implement a login handler that validates input, searches for the user by username, verifies active status and password, generates a token, and returns it as a response or cookie.

Implement a login route by checking user activity, decoding base64 salt and hashed password, hashing the input with Argon2, comparing hashes in constant time, and issuing a JWT on success.

Explore implementing jwt-based authentication in the login route by signing tokens, setting bearer cookies, and validating expiry, with practical testing and cookie handling.

Refactor the login route by extracting database access and password verification into a dedicated module, using generic error messages for security, and validating credentials to produce a token.

Implement a log out handler by clearing the JWT cookie, expiring it in the past, and setting http only, secure, and same-site attributes to log out securely.

Learn to build a Go jwt middleware that authenticates requests, protects all api routes with token parsing and validation, and uses context to propagate username, uid, role, and expiry.

Explore how to skip JWT middleware for prelogin routes by creating an exclude paths middleware, enabling secure login, token generation, and controlled access with CORS.

Implement update password route and exec handler to securely change a user's password by validating current and new passwords, hashing with salt, updating the database, and issuing a new token.

Implement a forgot password flow that sends a secure reset link after verifying the email, and test it with Go-based MailHog's SMTP server and web interface that captures reset emails.

Implement forgot password by accepting an email, checking the user in the database, generating a hashed, expiry-based reset token from env, and sending a reset link via go mail v2.

Implement a secure reset password flow by decoding and hashing the reset token, validating new and confirm passwords, and updating the user record while clearing reset fields.

Explore how cross-site request forgery threatens authenticated web actions and how token-based authentication with JWT, same-site cookies, and CSRF tokens mitigate risks in API design.

Implement pagination on the students route with limit and page, compute offset as (page-1)*limit, use defaults page=1 and limit=10, and expose total count; apply to teachers and exact routes.

Implement data sanitization as a server-side middleware for API inputs, cleaning path, query parameters, and JSON bodies with escaping, Blue Monday UGC policy to prevent XSS and SQL injection.

Implement role-based authorization by extracting roles from the jwt middleware context and validating them against allowed roles (admin, manager, exec) for teacher, student, and exec routes via a utils function.

Orchestrate a full middleware sequence for a Go API, integrating JWT, CORS, rate limiting, compression, security headers, response time, and XSS sanitization, with thoughtful path exclusions.

Learn how code obfuscation makes source and binary code harder to understand while preserving functionality, protecting intellectual property, and safeguarding API and server logic from reverse engineering and unauthorized access.

Embed the env file into the final binary with go embed, load its variables as OS environment variables, and read the certificate and key paths for production deployment.

Build and test cross-platform go api binaries with go build -o, target go os/arch combos, load envs from dot env files, enable tls and middlewares, and apply garble obfuscation.

Explore extensive benchmarking of go-based APIs, comparing source code, go binary, and obfuscated builds across HTTP/2 and HTTP/1.1, with and without TLS and middlewares, highlighting performance trade-offs.

Master Go concurrency and build native Go APIs with create, read, update, delete on MariaDB, custom middleware, advanced routing, authentication and authorization, plus curl and postman testing.

Learn how protocol buffers enable cross-language binary data serialization for networks and storage. See how the protoc compiler generates language-specific code from dot proto schemas, enabling microservices communication and APIs.

Explore the syntax and structure of dot proto files in protocol buffers, focusing on proto3: declare syntax, package, message definitions, field types, field numbers, and repeated fields using snake_case.

Define packages in protocol buffers to create namespaces for messages and enums, preventing naming conflicts across multiple proto files and imports, with generated code organized by package names.

Define messages in protocol buffers to structure data with fields, types, and field numbers for serialization, include nested messages and enums, proto files, and code generation for language classes.

Define protocol buffers fields by assigning a unique field number, a snake_case name, and a data type such as int32, string, or bool; use options and reserves for compatibility.

Explore Protocol Buffers field types—from int32 to uint64, fixed and zigzag variants, booleans, strings, bytes, enums, and nested messages with repeated and optional fields.

Understand field numbers in Protocol Buffers as unique identifiers from 1 to 536,870,911 for message serialization and deserialization. Use best practices: reserve numbers and prefer small ranges for common fields.

Explore serialization and deserialization in Protocol Buffers, converting messages defined in proto files to compact binary streams and back with generated code for efficient transmission, storage, and access.

Leverage RPC with Protocol Buffers to invoke remote procedures as local calls, define services in a dot proto file, and enable cross-language distributed communication.

Learn how to version protocol buffers messages and maintain backward compatibility as your Go services evolve, including field handling, deprecation, reserved numbers, versioned messages, and unit tests.

Discover best practices for designing proto files that improve maintainability, performance, and interoperability through clear names, grouped fields, enums, comments, versioning, flat structures, and placing common fields at the top.

Install and configure the protoc compiler to generate language-specific code from .proto files, set up environment PATH, and add the go plugin for protobuf to enable gRPC Go integration.

Practice protocol buffers by creating proto3 definitions for hello request and user profile, and generate Go code with protoc using go_package and folder structure.

Explore gRPC, a modern open source rpc framework built on http/2 and protocol buffers, enabling fast, language-agnostic communication with authentication, load balancing, and streaming for microservices.

Define a stub as code that stands in for unavailable functionality, enabling testing and prototyping in distributed systems via client side and server side stubs for RPC and gRPC.

Explain rest and gRPC architectures, compare resource-oriented rest with http and protocol buffers-based gRPC, including streaming, performance, and when to use each.

Install protoc-gen-go and protoc-gen-go-grpc, generate pb and grpc files from main.proto, implement the add RPC on a go gRPC server, and run it on port 50051.

Learn to create a Go gRPC client to test a proto-based API, generate code from the main proto file, handle insecure credentials, and call add to get a sum.

Implement TLS to secure gRPC communication by loading certificate and key as transport credentials, configuring server and client with TLS from file, and generating SAN-enabled certificates.

Learn to build a multi-service gRPC server in Go with protocol buffers, define messages and services across files, register services, and use per-service clients while managing imports.

Go bootcamp explores gRPC streaming, including server, client, and bidirectional streaming, enabling real-time data exchange, low latency, and chunked data delivery with practical examples.

Learn server side streaming with gRPC and protocol buffers by implementing a calculator service that streams fibonacci numbers in real time from server to client.

Demonstrate client-side streaming by sending a stream of int32 numbers from client to server, then the server returns a single number after the stream ends.

Explore bidirectional streaming with grpc and protocol buffers, implementing a chat rpc between client and server, generating protobufs, looping to receive and send messages, and using goroutines for concurrency.

Explore advanced gRPC features such as deadlines and timeouts, message compression with gunzip, server and client configuration, reflection, and the gRPC gateway for RESTful APIs to build robust services.

Learn how gRPC uses metadata as headers and trailers to send and receive key-value pairs. Set and extract request, response headers, and trailers on client and server, including authorization tokens.

Master using postman for gRPC to test unary, server and client streaming, and bidirectional RPCs, with example messages, TLS options, reflection, and handling metadata.

Learn how to install grpcurl, explore a gRPC server, list services and methods, and describe a service, including TLS with self-signed certificates and insecure or ca cert options.

Explore protoc gen validate plugin to generate validation code for protocol buffer messages in Go and gRPC, compare proto validate with protogen validate, and understand compile-time versus runtime validation implications.

Create a combo API that serves HTTP and gRPC via the gRPC gateway, using protocol buffers with Google API HTTP annotations, and run TLS-enabled gRPC and HTTP gateways together.

Benchmark the combo API using GHS and wrk to compare gRPC gateway performance against rest and TLS variants, revealing throughput and latency trends.