add

Author: sangam14

content/courses/quick-start-with-golang-modules/01-introduction.mdx

@@ -0,0 +1,46 @@
+---
+title: "Introduction to Go"
+description: "Learn about the Go programming language, its features, and why it's worth learning."
+order: 1
+---
+
+# Introduction to Go
+
+Go, often referred to as Golang, is a modern, statically-typed programming language designed for simplicity, efficiency, and reliability. Created by engineers at Google, it has gained significant popularity for its exceptional performance and ease of use.
+
+## Why Learn Go?
+
+Go has become increasingly popular for several reasons:
+
+- **Fast Compilation**: Go compiles directly to machine code, resulting in extremely fast build times
+- **Garbage Collection**: Automatic memory management without the overhead
+- **Concurrency Support**: Built-in concurrency primitives make it easy to write efficient concurrent programs
+- **Simple Syntax**: Clean, minimal syntax that's easy to read and write
+- **Strong Standard Library**: Rich built-in functionality for common tasks
+- **Cross-Platform**: Compile for different operating systems and architectures
+
+## Key Features of Go
+
+Go was designed with a few key principles in mind:
+
+### Simplicity
+
+Go's syntax is deliberately kept simple and clean. The language was designed to be easy to learn and read, with a minimal set of keywords and constructs. This makes Go code highly maintainable and accessible to newcomers.
+
+### Performance
+
+Go programs compile to native machine code, offering performance close to C/C++ while providing memory safety and garbage collection. Its compilation speed is remarkably fast, enabling quick development cycles.
+
+### Concurrency
+
+One of Go's standout features is its built-in support for concurrency through goroutines and channels. Goroutines are lightweight threads managed by the Go runtime, allowing you to run thousands of concurrent processes efficiently.
+
+### Standard Library
+
+Go comes with a comprehensive standard library that covers everything from HTTP servers to cryptography, making it possible to build complete applications without external dependencies.
+
+## Getting Started
+
+In the next modules, you'll learn how to set up your Go environment, write your first Go program, and understand fundamental concepts like variables, functions, and data structures.
+
+Let's embark on your Go programming journey! 

content/courses/quick-start-with-golang-modules/02-hello-world.mdx

@@ -0,0 +1,71 @@
+---
+title: "Hello World in Go"
+description: "Write and understand your first Go program"
+order: 2
+---
+
+# Hello World in Go
+
+Let's start with the traditional "Hello World" program. This simple program will help you understand the basic structure of a Go application.
+
+## Your First Go Program
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("Hello World")
+}
+```
+
+Let's break down this program:
+
+- `package main`: Every Go file starts with a package declaration. The `main` package is special - it defines an executable program rather than a library.
+- `import "fmt"`: This imports the format package from the standard library, which provides formatting functions.
+- `func main()`: The entry point of the program. Execution begins in the `main` function.
+- `fmt.Println("Hello World")`: This prints the text "Hello World" to the console.
+
+## Running Your First Program
+
+To run this program, save it as `hello.go` and execute the following command:
+
+```bash
+go run hello.go
+```
+
+You should see `Hello World` printed to your console.
+
+## Building an Executable
+
+You can also compile your program into a standalone executable:
+
+```bash
+go build hello.go
+```
+
+This will create an executable file named `hello` (or `hello.exe` on Windows). You can run this executable directly:
+
+```bash
+./hello
+```
+
+## Understanding Go Program Structure
+
+Every Go program follows a similar structure:
+
+1. **Package Declaration**: All Go files begin with `package <name>`. Executable programs use `package main`.
+2. **Import Statements**: Import other packages that your code needs.
+3. **Functions and Variables**: Declare functions and variables. The `main()` function is required for executable programs.
+4. **Code Comments**: Add documentation to your code using `//` for single-line comments or `/* */` for multi-line comments.
+
+## Exercise
+
+Try modifying the "Hello World" program to:
+
+1. Print your name instead of "Hello World"
+2. Print multiple lines using multiple `fmt.Println()` calls
+3. Add comments to explain what the program does
+
+In the next module, we'll explore Go's variables and data types. 

content/courses/quick-start-with-golang-modules/03-variables-and-types.mdx

@@ -0,0 +1,155 @@
+---
+title: "Variables and Data Types"
+description: "Learn about variables, data types, and how to work with them in Go"
+order: 3
+---
+
+# Variables and Data Types in Go
+
+Go is a statically typed language, which means variable types are checked at compile time. In this module, we'll explore Go's type system and how to work with variables.
+
+## Basic Types in Go
+
+Go has several built-in types:
+
+- **Numeric types**: 
+  - Integers: `int`, `int8`, `int16`, `int32`, `int64`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`
+  - Floating point: `float32`, `float64`
+  - Complex: `complex64`, `complex128`
+- **Boolean type**: `bool` (values: `true` and `false`)
+- **String type**: `string` (UTF-8 encoded text)
+- **Error type**: `error`
+
+## Variable Declaration
+
+There are several ways to declare variables in Go:
+
+### Method 1: Explicit Type
+
+```go
+var name string = "Gopher"
+var age int = 25
+var isActive bool = true
+```
+
+### Method 2: Type Inference
+
+Go can infer the type from the value:
+
+```go
+var name = "Gopher"  // string type is inferred
+var age = 25         // int type is inferred
+var isActive = true  // bool type is inferred
+```
+
+### Method 3: Short Variable Declaration
+
+Inside functions, you can use the short declaration operator (`:=`):
+
+```go
+name := "Gopher"
+age := 25
+isActive := true
+```
+
+This is the most common form used inside functions.
+
+## Multiple Variable Declaration
+
+You can declare multiple variables at once:
+
+```go
+var x, y, z int = 10, 20, 30
+
+// Or with type inference
+var a, b, c = "hello", 50, true
+
+// Or with short declaration
+firstName, lastName, age := "Go", "pher", 25
+```
+
+## Zero Values
+
+Variables declared without an explicit initial value are given their zero value:
+
+```go
+var i int       // Zero value: 0
+var f float64   // Zero value: 0.0
+var b bool      // Zero value: false
+var s string    // Zero value: "" (empty string)
+```
+
+## Constants
+
+Constants are declared using the `const` keyword:
+
+```go
+const Pi = 3.14159
+const (
+    StatusOK = 200
+    StatusNotFound = 404
+)
+```
+
+Constants can be character, string, boolean, or numeric values.
+
+## Type Conversion
+
+Go doesn't automatically convert between types. You must explicitly convert:
+
+```go
+var i int = 42
+var f float64 = float64(i)
+var u uint = uint(f)
+```
+
+## Example: Working with Different Types
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // Different ways to declare variables
+    var a int = 10
+    var b = 20
+    c := 30
+    
+    // Zero values
+    var d int
+    var e string
+    var f bool
+    
+    // Constants
+    const Pi = 3.14
+    
+    fmt.Println("a:", a)
+    fmt.Println("b:", b)
+    fmt.Println("c:", c)
+    fmt.Println("d (zero value):", d)
+    fmt.Println("e (zero value):", e)
+    fmt.Println("f (zero value):", f)
+    fmt.Println("Pi:", Pi)
+}
+```
+
+## Type Checking in Action
+
+Go's type system helps catch errors at compile time:
+
+```go
+x := 10
+y := "hello"
+z := x + y  // This will cause a compile-time error
+```
+
+The above code won't compile because Go doesn't allow adding an integer and a string.
+
+## Exercise
+
+1. Create a program that declares variables of different types
+2. Try converting between different types
+3. Experiment with zero values and constants
+
+In the next module, we'll look at control structures in Go (if statements, loops, and switches).