add

Author: sangam14

content/courses/concurrent-programming-with-go-labs/01-introduction-to-concurrency.mdx

@@ -0,0 +1,52 @@
+---
+title: 'Introduction to Concurrency in Go'
+slug: 'introduction-to-concurrency'
+---
+
+# Introduction to Concurrency in Go
+
+Concurrency is one of Go's most powerful features, but it's often misunderstood. Let's start by clarifying what concurrency actually means.
+
+## Concurrency vs Parallelism
+
+> Concurrency is not parallelism
+
+Some quotes to support this statement:
+
+> "Concurrency is a property of the code; parallelism is a property of the running program"
+
+> "Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once."
+
+Concurrency refers to the design pattern where multiple tasks can make progress independently, even if they're not executing simultaneously. Parallelism, on the other hand, is about executing multiple tasks simultaneously.
+
+In Go, concurrency is built into the language design with three main components:
+
+* **Concurrency execution (goroutines)** - Lightweight threads managed by the Go runtime
+* **Synchronization and messaging (channels)** - Safe communication between concurrent code
+* **Multi-way concurrent control (select)** - Coordination of multiple concurrent operations
+
+## Why Go's Approach to Concurrency is Different
+
+Go provides first-class support for concurrent code in a program, and channels solve the problem of communicating safely between concurrently running code.
+
+Go also supports more traditional tools for writing concurrent code. Mutexes, pools, and locks are implemented in the sync package, but channels are often preferred for their simplicity and readability.
+
+## Key Concurrency Features in Go
+
+1. **Goroutines**: Lightweight threads that allow functions to run concurrently
+2. **Channels**: Communication pipes that allow goroutines to share data safely
+3. **Select Statement**: A control structure for handling multiple channel operations
+4. **WaitGroups**: A synchronization mechanism from the sync package
+5. **Mutex**: A way to protect shared data from concurrent access
+6. **Context Package**: Tools for cancellation, deadlines, and request-scoped values
+
+In the following labs, we'll explore each of these features in depth and learn how to use them to write efficient concurrent programs.
+
+## Summary
+
+- Concurrency is about structure, parallelism is about execution
+- Go has built-in language features for concurrency
+- Go's approach favors communication over shared memory
+- Understanding concurrency patterns is essential for writing efficient Go programs
+
+In the next lab, we'll dive deeper into channels, the fundamental communication mechanism in Go's concurrency model. 

content/courses/concurrent-programming-with-go-labs/02-channels-basics.mdx

@@ -0,0 +1,103 @@
+---
+title: 'Channels Basics'
+slug: 'channels-basics'
+---
+
+# Channels Basics
+
+Channels are one of the core features of Go's concurrency model. They provide a way for goroutines to communicate with each other and synchronize their execution.
+
+## What are Channels?
+
+Channels can be imagined as a pipe for streams of data. They are used to communicate information between goroutines. The fundamental philosophy in Go is:
+
+> Don't communicate by sharing memory; share memory by communicating.
+
+This means instead of using shared variables with locks, Go encourages passing data through channels.
+
+## Creating a Channel
+
+Creating a channel in Go is simple:
+
+```go
+channel := make(chan interface{})
+```
+
+This creates a channel that can send and receive values of any type (though it's usually better to use a specific type).
+
+Here's a more typical example, creating a channel that handles string values:
+
+```go
+messages := make(chan string)
+```
+
+## Sending and Receiving
+
+Channels use two primary operations:
+- The send operation `chan <-` sends a value into a channel
+- The receive operation `<-chan` receives a value from a channel
+
+Let's see a simple example:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // Create a new channel
+    messages := make(chan string)
+
+    // Send a value into the channel (in a separate goroutine)
+    go func() { 
+        messages <- "ping" 
+    }()
+
+    // Receive the value from the channel
+    msg := <-messages
+    fmt.Println(msg)
+}
+```
+
+When you run this program, you'll see the output:
+```
+ping
+```
+
+## Channel Blocking
+
+Channels are inherently blocking. This means:
+
+1. A send operation `channel <- value` blocks until a receiver is ready to receive the value
+2. A receive operation `value := <-channel` blocks until a sender sends a value
+
+This blocking behavior is what makes channels so powerful for synchronization between goroutines.
+
+## Channel Types
+
+There are different types of channels in Go:
+- **Bidirectional channels**: The default type, can be both read from and written to
+- **Directional channels**: Restricted to either sending or receiving
+- **Buffered channels**: Can hold a limited number of values without a receiver being ready
+
+In the next labs, we'll explore each of these types in detail.
+
+## When to Use Channels
+
+Channels are ideal for:
+
+1. Communicating between goroutines
+2. Signaling completion of tasks
+3. Distributing work among multiple goroutines
+4. Managing concurrency with timeouts and cancellation
+
+## Summary
+
+- Channels are a communication mechanism between goroutines
+- The syntax for creating a channel is `make(chan Type)`
+- Send values with `channel <- value`
+- Receive values with `value := <-channel`
+- Channels block until the operation can proceed
+- Channels provide built-in synchronization
+
+In the next lab, we'll explore bidirectional channels in more detail. 

content/courses/concurrent-programming-with-go-labs/03-bidirectional-channels.mdx

@@ -0,0 +1,142 @@
+---
+title: 'Bidirectional Channels'
+slug: 'bidirectional-channels'
+---
+
+# Bidirectional Channels
+
+By default, channels in Go are bidirectional, which means they can be used to both send and receive values. This is the simplest form of a channel and is what you get when you create a channel without any direction-specific notation.
+
+## Creating a Bidirectional Channel
+
+Creating a bidirectional channel is straightforward:
+
+```go
+// Create a bidirectional channel for string values
+messages := make(chan string)
+```
+
+## Using a Bidirectional Channel
+
+Let's look at a simple example that demonstrates sending and receiving on a bidirectional channel:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    messages := make(chan string)
+    
+    // Send a value into the channel in a separate goroutine
+    go func() { 
+        messages <- "ping" 
+    }()
+
+    // Receive the value from the channel
+    msg := <-messages
+    fmt.Println(msg)
+}
+```
+
+In this example:
+1. We create a bidirectional channel called `messages`
+2. We launch a goroutine that sends the string "ping" into the channel
+3. The main goroutine receives the value from the channel
+4. The received value is printed
+
+## Benefits and Limitations
+
+**Benefits:**
+- Simple to use and understand
+- Flexible - can be used for both sending and receiving
+- No need to specify direction when creating the channel
+
+**Limitations:**
+- Anyone can read and write to the channel
+- This can cause problems in concurrent environments where you want to restrict operations
+- No type safety to prevent incorrect usage
+
+## When to Use Bidirectional Channels
+
+Bidirectional channels are most appropriate when:
+
+1. You have a simple communication pattern
+2. The same goroutine might need to both send and receive
+3. You're prototyping and don't need strict access control
+
+## Common Patterns with Bidirectional Channels
+
+### Ping-Pong Pattern
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+func ping(ch chan string) {
+    ch <- "ping"
+}
+
+func pong(ch chan string) {
+    msg := <-ch
+    fmt.Println(msg)
+    ch <- "pong"
+}
+
+func main() {
+    ch := make(chan string)
+    
+    go ping(ch)
+    go pong(ch)
+    
+    fmt.Println(<-ch)
+    time.Sleep(100 * time.Millisecond) // Ensure the goroutines have time to execute
+}
+```
+
+### Basic Worker Pattern
+
+```go
+package main
+
+import "fmt"
+
+func worker(jobs chan int, results chan int) {
+    for job := range jobs {
+        results <- job * 2 // Double the job value
+    }
+}
+
+func main() {
+    jobs := make(chan int, 5)
+    results := make(chan int, 5)
+    
+    // Start a worker
+    go worker(jobs, results)
+    
+    // Send jobs
+    for i := 1; i <= 3; i++ {
+        jobs <- i
+    }
+    close(jobs)
+    
+    // Collect results
+    for i := 1; i <= 3; i++ {
+        fmt.Println(<-results)
+    }
+}
+```
+
+## Summary
+
+- Bidirectional channels can be used for both sending and receiving
+- They're created with `make(chan Type)`
+- They're the default channel type in Go
+- They offer flexibility but less type safety than directional channels
+- They're great for simple communication patterns
+
+In the next lab, we'll look at directional channels, which add type safety by restricting operations to either sending or receiving.