Learn Go Programming From Scratch && Crack Golang Interviews

Learn how Go handles data types and variables, declaring with var or colon equals, initializing multiple variables on one line, and printing results using the format package.

Learn Go's signed and unsigned integers across four sizes—8, 16, 32, and 64 bits—with int8, int16, int32, int64 and uint8, uint16, uint32, uint64, and see their ranges and sample prints.

learn how to name and declare Go variables, including valid patterns, type inference with :=, and zero values; explore scope across functions and printing of ints and strings.

Explore constants in Go, immutable values declared with the const keyword, illustrated by constant strings and integers like x and y, and the compile-time error when attempting reassignment.

Learn how arithmetic operators in Go combine numbers and strings into expressions, including addition, subtraction, multiplication, division, and remainder, with integer division yielding zero fractions.

Explore bitwise operators and how they perform per-bit calculations on integers, demonstrated with x=75 and y=25 using and, or, and xor to yield 9, 91, and 82.

Learn Go comparison operators such as equals, not equal to, less than, greater than, and equal-to forms, with boolean results, logical operators like &&, ||, and !, and assignment operators.

Define and call functions in Go, pass integer parameters, return values, and export functions to other packages, using function signatures and the func keyword.

Master Go's defer statements that run after a function completes in the last in first out order, with deferred calls, work even when a panic occurs, and aid resource management.

Explore variadic functions in Go, learning how an ellipsis enables a function to accept any number of arguments. See examples with strings, interfaces, and type printing using reflect.

Explore how Go's panic interrupts normal execution, stack-unwinds with deferred calls, and can be triggered by runtime errors or explicit panics, with diagnostic log messages for debugging.

Learn how panic and recover work in Go, using defer to recover from runtime errors and nil checks, and understand recovery only within the same goroutine.

Learn how Go arrays are fixed-size collections of a type, with length as part of the type and zero-value elements. See value-copy behavior when assigning or passing arrays to functions.

Explore Go array handling by using the len function, for loops, and range to print the index and value, including ignoring the index with an underscore.

Learn how to work with two dimensional arrays in Go by building a 3x2 matrix, initializing values, and printing the elements row by row using nested for loops.

Explore Go slices as flexible references to an underlying array, learn slice creation with start to end, understand length and capacity, and see how edits propagate to all slices.

Explore slices in Go by creating with make, inspecting length and capacity, appending elements (including from nil slices), using the ellipsis to append slices, and building multi-dimensional slices.

Explore maps in Go, a built-in type linking keys to values created with make. Learn to add, access, and print contents, and handle missing keys returning zero values.

Learn how to check key presence in a map, handle values with if-else, iterate with for range, delete keys, and understand maps as reference types in Go.

Explain strings in Go as slices of bytes, show creation with quotes, access bytes and ASCII hex values, and demonstrate range-based iteration, rune handling, and string immutability with byte-slice mutations.

Learn how pointers store memory addresses, how to dereference and modify values via pointers, and how to pass pointers to functions and work with arrays and slices in Go.

Learn how Go structures group fields into a single unit, with named and anonymous forms, using basket, fruits, and vegetables to illustrate field access, initialization, and pointers.

Explore anonymous fields in Go structures, including how fields with only a type become named by their type, and how to access and promote them in nested structs.

Explore how exported structs and fields become accessible across packages, and see how unexported fields remain private, in a sample Go project using a computer package and exported fields.

Learn that Go structures are value types and are equal when all fields are comparable, including strings. See that maps inside a struct break comparability and cause a compiler error.

Learn how Go attaches behavior to types using methods with receivers on types, illustrated by a method on X that prints A and B, and why they differ from functions.

Explore Go methods with value and pointer receivers, show how changes propagate differently, compare copying costs, and demonstrate methods on anonymous fields and access behavior.

Clarify value receivers in methods versus value arguments in functions in Go, cover pointer receivers, passing by value or pointer, and how methods and functions can share names.

Explore Go interfaces, where a type implements an interface by its methods with implicit declarations, and use slices of interfaces to write extensible code.

Explore the empty interface in Go, which any type implements, and use type assertion and type switches to extract underlying values and dispatch by concrete types.

Implement interfaces in go by using pointer and value receivers, define and invoke interface methods on structs, and explore interface assignments and method calls that print internal fields.

Explore implementing multiple interfaces in Go, embedding interfaces to create a composite interface, and handle zero value and nil scenarios along with panics when interfaces lack values.

Explore concurrency and parallelism in Go, and discover how go routines provide lightweight concurrency and how channels enable safe inter-routine communication through practical browser scenarios.

Learn how Go channels enable inter-goroutine communication through typed channels, with make, nil values, and blocking send and receive to synchronize execution.

Explore go channels, avoid deadlock and runtime panic by ensuring senders and receivers synchronize; learn unidirectional channels, bidirectional conversions, and closing channels to signal completion.

Discover how buffered channels in Go enable a capacity buffer, blocking on full or empty, with an example using a capacity of two and concurrent sends, reads, and channel closing.

Learn how buffered channels in Go can deadlock when writes exceed capacity without readers, and how a WaitGroup coordinates multiple goroutines with Add, Done, and Wait.

Explore how Go's select statement chooses among multiple channel operations, waiting for the first ready send or receive and optionally using a default case to avoid blocking.

Explore how the select statement reads from channels, how a default case prevents deadlock, and how an empty select can still block or panic in Go.

Explore how Go replaces classes with structs and methods, bundling data with behavior. Use a custom package and Go workspace to illustrate struct-based design.

Go lacks constructors; zero value structs can be unusable, so create a constructor-like new function to return a fully initialized object with required parameters.

Explore composition in Go by embedding structs with anonymous fields, accessing embedded fields and methods, and printing outcomes through practical struct examples.

Explore Go's defer statement and how it defers function calls until just before return. See how deferred arguments are evaluated at deferral and how a lifo defer stack controls execution.

Go treats errors as values, with nil for success and non-nil for failure, and functions like open return a result and an error to be checked and handled.

Learn to create custom errors in Go using new and errors packages, implement custom error types to carry data like the radius, and handle negative input when calculating circle area.

Explore panic and recover in Go: learn how panics terminate a program, how recover inside deferred functions regains control, and how defers execute before unwinding the stack.

Explore panics from out-of-bounds access in Go. Learn to recover from panics with the recover function, inspect control flow, and view stack traces printed by the debug package.

Go supports first-class functions, enabling anonymous functions, passing functions as arguments, defining function types, and higher-order functions; closures bind to surrounding variables.