add

Author: sangam14

content/courses/concurrent-programming-with-go.mdx

@@ -91,24 +91,24 @@ Before starting this course, you should have:
 
 This course is divided into several modules to help you learn concurrent programming in Go step by step:
 
-1. [Introduction to Concurrency](/courses/concurrent-programming-with-go-modules/01-introduction-to-concurrency) - Understand concurrency vs parallelism and Go's approach.
-2. [Channels Basics](/courses/concurrent-programming-with-go-modules/02-channels-basics) - Learn about Go's primary communication mechanism.
-3. [Bidirectional Channels](/courses/concurrent-programming-with-go-modules/03-bidirectional-channels) - See how channels can send and receive data.
-4. [Directional Channels](/courses/concurrent-programming-with-go-modules/04-directional-channels) - Learn about send-only and receive-only channels.
-5. [Buffered Channels](/courses/concurrent-programming-with-go-modules/05-buffered-channels) - Work with channels that can store multiple values.
-6. [Creating Goroutines](/courses/concurrent-programming-with-go-modules/06-creating-goroutines) - Launch lightweight threads in Go.
-7. [Working with WaitGroups](/courses/concurrent-programming-with-go-modules/07-working-with-waitgroups) - Coordinate multiple goroutines.
-8. [Testing with WaitGroups](/courses/concurrent-programming-with-go-modules/08-testing-with-waitgroups) - Write tests for concurrent code.
-9. [Race Conditions](/courses/concurrent-programming-with-go-modules/09-race-conditions) - Identify and understand race conditions.
-10. [Using Mutex](/courses/concurrent-programming-with-go-modules/10-using-mutex) - Protect shared resources from concurrent access.
-11. [The Producer-Consumer Problem](/courses/concurrent-programming-with-go-modules/11-producer-consumer-problem) - Solve this classic concurrency challenge.
-12. [Range over Channels](/courses/concurrent-programming-with-go-modules/12-range-over-channels) - Iterate over channel values elegantly.
-13. [Unbuffered Channels](/courses/concurrent-programming-with-go-modules/13-unbuffered-channels) - Understand synchronization with unbuffered channels.
-14. [Buffered vs Unbuffered Channels](/courses/concurrent-programming-with-go-modules/14-buffered-vs-unbuffered) - Compare the two channel types.
-15. [Channel Direction](/courses/concurrent-programming-with-go-modules/15-channel-direction) - Enforce data flow direction.
-16. [Channel Ownership](/courses/concurrent-programming-with-go-modules/16-channel-ownership) - Establish clear ownership patterns.
-17. [Pipeline Pattern](/courses/concurrent-programming-with-go-modules/17-pipeline-pattern) - Process data through a series of stages.
-18. [Fan-Out Fan-In Pattern](/courses/concurrent-programming-with-go-modules/18-fan-out-fan-in) - Distribute and collect work among goroutines.
-19. [Cancellation with Context Package](/courses/concurrent-programming-with-go-modules/19-context-package) - Manage goroutine lifecycles and cancellation.
+1. [Introduction to Concurrency](/courses/concurrent-programming-with-go/introduction-to-concurrency) - Understand concurrency vs parallelism and Go's approach.
+2. [Channels Basics](/courses/concurrent-programming-with-go/channels-basics) - Learn about Go's primary communication mechanism.
+3. [Bidirectional Channels](/courses/concurrent-programming-with-go/bidirectional-channels) - See how channels can send and receive data.
+4. [Directional Channels](/courses/concurrent-programming-with-go/directional-channels) - Learn about send-only and receive-only channels.
+5. [Buffered Channels](/courses/concurrent-programming-with-go/buffered-channels) - Work with channels that can store multiple values.
+6. [Creating Goroutines](/courses/concurrent-programming-with-go/creating-goroutines) - Launch lightweight threads in Go.
+7. [Working with WaitGroups](/courses/concurrent-programming-with-go/working-with-waitgroups) - Coordinate multiple goroutines.
+8. [Testing with WaitGroups](/courses/concurrent-programming-with-go/testing-with-waitgroups) - Write tests for concurrent code.
+9. [Race Conditions](/courses/concurrent-programming-with-go/race-conditions) - Identify and understand race conditions.
+10. [Using Mutex](/courses/concurrent-programming-with-go/using-mutex) - Protect shared resources from concurrent access.
+11. [The Producer-Consumer Problem](/courses/concurrent-programming-with-go/producer-consumer-problem) - Solve this classic concurrency challenge.
+12. [Range over Channels](/courses/concurrent-programming-with-go/range-over-channels) - Iterate over channel values elegantly.
+13. [Unbuffered Channels](/courses/concurrent-programming-with-go/unbuffered-channels) - Understand synchronization with unbuffered channels.
+14. [Buffered vs Unbuffered Channels](/courses/concurrent-programming-with-go/buffered-vs-unbuffered) - Compare the two channel types.
+15. [Channel Direction](/courses/concurrent-programming-with-go/channel-direction) - Enforce data flow direction.
+16. [Channel Ownership](/courses/concurrent-programming-with-go/channel-ownership) - Establish clear ownership patterns.
+17. [Pipeline Pattern](/courses/concurrent-programming-with-go/pipeline-pattern) - Process data through a series of stages.
+18. [Fan-Out Fan-In Pattern](/courses/concurrent-programming-with-go/fan-out-fan-in) - Distribute and collect work among goroutines.
+19. [Cancellation with Context Package](/courses/concurrent-programming-with-go/context-package) - Manage goroutine lifecycles and cancellation.
 
 Let's explore how Go's concurrency model makes it easy to write concurrent programs that are both efficient and easy to reason about! 

content/courses/concurrent-programming-with-go/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. 

content/courses/concurrent-programming-with-go/buffered-channels.mdx

@@ -0,0 +1,159 @@
+---
+title: 'Buffered Channels'
+slug: 'buffered-channels'
+---
+
+# Buffered Channels
+
+By default, channels in Go are unbuffered, meaning they will only accept sends (`chan <-`) if there is a corresponding receiver (`<-chan`) ready to receive the value. Buffered channels, on the other hand, can hold a limited number of values without a corresponding receiver.
+
+## Creating a Buffered Channel
+
+To create a buffered channel, you specify the buffer size as the second argument to `make`:
+
+```go
+// Create a buffered channel with capacity of 2
+messages := make(chan string, 2)
+```
+
+## How Buffered Channels Work
+
+Buffered channels work like queues:
+
+1. When you send a value, it's added to the end of the queue
+2. When you receive a value, it's taken from the front of the queue
+3. If the queue is full, sends will block
+4. If the queue is empty, receives will block
+
+## Example of a Buffered Channel
+
+Here's a simple example demonstrating buffered channels:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    // Create a buffered channel with a capacity of 2
+    messages := make(chan string, 2)
+    
+    // Send two values into the channel without a receiver
+    messages <- "buffered"
+    messages <- "channel"
+    
+    // Receive the two values
+    fmt.Println(<-messages)  // Output: buffered
+    fmt.Println(<-messages)  // Output: channel
+}
+```
+
+Notice how in this example:
+- We can send two values into the channel without any goroutine ready to receive
+- The sends don't block because the buffer isn't full yet
+- If we tried to send a third value without first receiving any, the send would block
+
+## When to Use Buffered Channels
+
+Buffered channels are useful in several scenarios:
+
+1. **Reducing goroutine blocking**: When the sender doesn't need to wait for the receiver to be ready
+2. **Bursty workloads**: When the rate of sends and receives varies over time
+3. **Batching operations**: When you want to process items in batches rather than one at a time
+4. **Producer/consumer patterns**: When producers might temporarily produce faster than consumers can consume
+
+## Choosing a Buffer Size
+
+Selecting an appropriate buffer size depends on your specific use case:
+
+- **Too small**: May cause unnecessary blocking and reduce concurrency
+- **Too large**: May hide synchronization bugs and consume too much memory
+- **Just right**: Provides enough capacity to smooth out temporary rate differences
+
+As a general rule, use the smallest buffer size that prevents unnecessary blocking.
+
+## Example: Worker Pool with Buffered Channels
+
+Here's a more practical example using buffered channels to implement a worker pool:
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+func worker(id int, jobs <-chan int, results chan<- int) {
+    for job := range jobs {
+        fmt.Printf("Worker %d processing job %d\n", id, job)
+        time.Sleep(time.Second) // Simulate work
+        results <- job * 2
+    }
+}
+
+func main() {
+    // Create buffered channels
+    jobs := make(chan int, 100)
+    results := make(chan int, 100)
+    
+    // Start workers
+    for w := 1; w <= 3; w++ {
+        go worker(w, jobs, results)
+    }
+    
+    // Send jobs
+    for j := 1; j <= 9; j++ {
+        jobs <- j
+    }
+    close(jobs)
+    
+    // Collect results
+    for a := 1; a <= 9; a++ {
+        <-results
+    }
+}
+```
+
+In this example:
+- The buffered `jobs` channel allows us to queue up jobs without waiting for workers
+- The buffered `results` channel allows workers to report results without waiting for the main goroutine
+
+## Channel Blocking Behavior with Buffers
+
+Understanding when buffered channels block is crucial:
+
+1. **Send operation** (`ch <- value`):
+   - Blocks when the buffer is full
+   - Doesn't block when the buffer has space
+
+2. **Receive operation** (`<-ch`):
+   - Blocks when the buffer is empty
+   - Doesn't block when the buffer has at least one value
+
+## Deadlocks with Buffered Channels
+
+Even with buffered channels, deadlocks can still occur. Common causes include:
+
+- Buffer too small for the number of sends
+- Forgetting to close channels
+- Circular dependencies between goroutines
+
+## Performance Considerations
+
+Some performance characteristics to keep in mind:
+
+- Unbuffered channels are slightly faster than buffered channels for synchronization
+- Larger buffer sizes don't necessarily mean better performance
+- The optimal buffer size depends on your specific workload patterns
+
+## Summary
+
+- Buffered channels have a capacity that allows them to hold multiple values
+- They're created with `make(chan Type, capacity)`
+- Sends only block when the buffer is full
+- Receives only block when the buffer is empty
+- They're useful for decoupling senders and receivers
+- Choose buffer sizes carefully based on your specific use case
+
+In the next lab, we'll explore how to create and work with goroutines, Go's lightweight threads for concurrent execution.