# **🐹 Booth: Go (2009)** * **Creator:** Robert Griesemer, Rob Pike, and Ken Thompson (Google) * **Design Philosophy:** Simplicity, readability, and speed at scale. Go trades complex language abstractions for a clean, highly optimized execution model that compiles directly to machine code in seconds. * **Key Innovations:** Goroutines (M:N scheduler), channels, structural interfaces, and Communicating Sequential Processes (CSP) concurrency. ## **🚀 Hello, World\!** package main import "fmt" fn main() { fmt.Println("Hello, World\!") } ## **🎨 Showpiece: Concurrent Pipelines via Channels** Go structures concurrency via green threads called "goroutines" executing concurrently. They communicate over typed FIFO pipelines called "channels." We represent a parallel sequence pipeline with data streams passing through computational processing stages: ![][image1]package main import ( "fmt" "time" ) // Generates integer streams asynchronously func generator(nums \[\]int, out chan\<- int) { for \_, n := range nums { out \<- n // block-send until buffer processes it } close(out) } // Squares the incoming integer streams asynchronously func squarer(in \<-chan int, out chan\<- int) { for n := range in { out \<- n \* n } close(out) } func main() { fmt.Println("\[Go Runtime\] Spawning concurrent generator & worker...") // Create unbuffered channels inputChan := make(chan int) outputChan := make(chan int) numberList := \[\]int{2, 4, 6, 8} // Spin off isolated goroutines to handle computation go generator(numberList, inputChan) go squarer(inputChan, outputChan) // Consume outcomes sequentially for value := range outputChan { time.Sleep(50 \* time.Millisecond) // Simulate lightweight I/O wait fmt.Printf("\[Consumer\] Received result: %d\\n", value) } fmt.Println("\[Go Runtime\] All channels drained and closed. Process safe.") } [image1]: