add

Author: sangam14

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

@@ -19,6 +19,10 @@ Go was designed with the following goals in mind:
 - **Fast compilation**: Go compiles quickly, enabling rapid development cycles
 - **Modern standard library**: Comprehensive built-in packages for common tasks
 
+<Callout type="info">
+  Go is being used by major companies like Google, Uber, Dropbox, and Twitch, demonstrating its ability to scale and perform in production environments.
+</Callout>
+
 ## Key Features of Go
 
 ### Static Typing with Type Inference
@@ -31,32 +35,72 @@ message := "Hello, Go!"
 
 // Type is explicitly declared
 var count int = 42
+
+// Multiple variable declarations
+var (
+    name    string = "Gopher"
+    age     int    = 5
+    isAlive bool   = true
+)
 ```
 
 ### Concurrency with Goroutines
 
 Go's lightweight threads (goroutines) make concurrent programming accessible:
 
 ```go
-// Start a concurrent function
-go fetchData()
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+func sayHello(message string) {
+    fmt.Println(message)
+}
+
+func main() {
+    // Start concurrent functions
+    go sayHello("Hello from goroutine 1")
+    go sayHello("Hello from goroutine 2")
+    
+    // Wait to see the output
+    time.Sleep(100 * time.Millisecond)
+    fmt.Println("Main function continues...")
+}
 ```
 
 ### Channels for Communication
 
 Channels provide a safe way for goroutines to communicate:
 
 ```go
-// Create a channel
-dataChan := make(chan string)
-
-// Send data to the channel
-dataChan <- "Some data"
-
-// Receive data from the channel
-receivedData := <-dataChan
+package main
+
+import "fmt"
+
+func main() {
+    // Create a channel
+    dataChan := make(chan string)
+    
+    // Send data in a goroutine
+    go func() {
+        dataChan <- "Hello from channel!"
+    }()
+    
+    // Receive data from the channel
+    receivedData := <-dataChan
+    fmt.Println(receivedData) // Prints: Hello from channel!
+}
 ```
 
+<Section>
+  <h2>Comparing Go with Other Languages</h2>
+  <p>Unlike languages like Python or JavaScript, Go is compiled rather than interpreted, giving it performance advantages. While C++ may be slightly faster in some cases, Go offers a much simpler learning curve and built-in memory management.</p>
+  <p>Go strikes an excellent balance between performance, simplicity, and developer productivity.</p>
+</Section>
+
 ## Getting Started
 
 In the next module, we'll set up our Go environment and write our first Go program. You'll see firsthand how Go's simplicity and power make it an excellent choice for modern software development.

content/courses/quick-start-with-golang-modules/custom-code-highlighting.mdx

@@ -0,0 +1,132 @@
+---
+title: "Advanced Code Highlighting Features"
+description: "Learn how to use the enhanced code block features like line highlighting, titles, and more."
+order: 102
+---
+
+# Advanced Code Highlighting Features
+
+This page demonstrates how to use the advanced features of our code blocks.
+
+## Line Highlighting
+
+You can highlight specific lines in your code to draw attention to them. This is done using the `highlight` attribute:
+
+```go highlight="3,5-7"
+package main
+
+import "fmt" // This line is highlighted
+
+func main() {
+    // These lines are highlighted
+    message := "Hello, highlighted code!"
+    fmt.Println(message)
+}
+```
+
+## Code Block Titles
+
+You can add a title to your code blocks using the `title` attribute:
+
+```go title="hello.go"
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("Hello from a titled code block!")
+}
+```
+
+## Hiding Line Numbers
+
+You can hide line numbers if you prefer a cleaner look using the `showLineNumbers` attribute:
+
+```go showLineNumbers="false"
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("No line numbers here!")
+}
+```
+
+## Combining Features
+
+You can combine multiple features for rich code examples:
+
+```go title="example.go" highlight="7-9"
+package main
+
+import (
+    "fmt"
+    "time"
+)
+func calculateFibonacci(n int) int {
+    // Highlighted implementation
+    if n <= 1 {
+        return n
+    }
+    return calculateFibonacci(n-1) + calculateFibonacci(n-2)
+}
+
+func main() {
+    start := time.Now()
+    result := calculateFibonacci(10)
+    elapsed := time.Since(start)
+    
+    fmt.Printf("Fibonacci(10) = %d\n", result)
+    fmt.Printf("Time taken: %s\n", elapsed)
+}
+```
+
+## Comparison with Other Languages
+
+Go syntax is clean and straightforward compared to other languages:
+
+### Go (Golang)
+
+```go
+package main
+
+import "fmt"
+
+type Person struct {
+    Name string
+    Age  int
+}
+
+func main() {
+    p := Person{Name: "Alice", Age: 30}
+    fmt.Printf("%s is %d years old\n", p.Name, p.Age)
+}
+```
+
+### JavaScript
+
+```javascript
+class Person {
+    constructor(name, age) {
+        this.name = name;
+        this.age = age;
+    }
+}
+
+const person = new Person('Alice', 30);
+console.log(`${person.name} is ${person.age} years old`);
+```
+
+### Python
+
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+person = Person('Alice', 30)
+print(f"{person.name} is {person.age} years old")
+```
+
+By using these code block features, you can create more engaging and educational Go tutorials that highlight the most important parts of your code examples. 

content/courses/quick-start-with-golang-modules/example-code-highlighting.mdx

@@ -0,0 +1,155 @@
+---
+title: "Code Highlighting Examples"
+description: "Learn how to use various code syntax highlighting features in Go examples"
+order: 101
+---
+
+# Go Code Syntax Highlighting Examples
+
+This page demonstrates the enhanced code highlighting capabilities of GolangMastery.
+
+## Basic Hello World
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // This is a comment
+    fmt.Println("Hello, World!")
+}
+```
+
+## Functions and Types
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+// Person represents a human being
+type Person struct {
+    Name     string
+    Age      int
+    Birthday time.Time
+}
+
+func (p *Person) Greet() string {
+    return fmt.Sprintf("Hello, my name is %s and I am %d years old.", p.Name, p.Age)
+}
+
+func NewPerson(name string, age int) *Person {
+    return &Person{
+        Name: name,
+        Age:  age,
+    }
+}
+
+func main() {
+    person := NewPerson("John Doe", 30)
+    fmt.Println(person.Greet())
+    
+    // Numbers demonstration
+    const pi = 3.14159
+    var count int64 = 42
+    
+    // Boolean values
+    var isGolangFun bool = true
+    
+    if isGolangFun {
+        fmt.Println("Learning Go is fun!")
+    }
+}
+```
+
+## Error Handling
+
+```go
+package main
+
+import (
+    "errors"
+    "fmt"
+    "os"
+)
+
+func readFile(filename string) (string, error) {
+    if filename == "" {
+        return "", errors.New("filename cannot be empty")
+    }
+    
+    data, err := os.ReadFile(filename)
+    if err != nil {
+        return "", fmt.Errorf("failed to read file: %w", err)
+    }
+    
+    return string(data), nil
+}
+
+func main() {
+    content, err := readFile("example.txt")
+    if err != nil {
+        fmt.Printf("Error: %v\n", err)
+        return
+    }
+    
+    fmt.Println("File contents:", content)
+}
+```
+
+## Goroutines and Channels
+
+```go
+package main
+
+import (
+    "fmt"
+    "sync"
+    "time"
+)
+
+func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
+    defer wg.Done()
+    
+    for j := range jobs {
+        fmt.Printf("Worker %d started job %d\n", id, j)
+        time.Sleep(time.Second)
+        fmt.Printf("Worker %d finished job %d\n", id, j)
+        results <- j * 2
+    }
+}
+
+func main() {
+    const numJobs = 5
+    const numWorkers = 3
+    
+    jobs := make(chan int, numJobs)
+    results := make(chan int, numJobs)
+    
+    // Start workers
+    var wg sync.WaitGroup
+    for w := 1; w <= numWorkers; w++ {
+        wg.Add(1)
+        go worker(w, jobs, results, &wg)
+    }
+    
+    // Send jobs
+    for j := 1; j <= numJobs; j++ {
+        jobs <- j
+    }
+    close(jobs)
+    
+    // Wait for all workers to complete
+    wg.Wait()
+    close(results)
+    
+    // Collect results
+    for r := range results {
+        fmt.Println("Result:", r)
+    }
+}
+```