Why is Go cool?

Effortless Concurrency

• 'go' keyword creates a 'goroutine' to run the supplied function
• "channel" is a native compound data type - like a buffered queue with blocking capabilities
• goroutines are multiplexed on OS threads by the runtime - you don't have to care how
• no locks or mutexes to manage

Strong Typing AND Duck Typing

• If a type implements an interface, it's regarded as being that kind of thing
• Go isn't object-oriented -- think types and interfaces
• A notion of OOP is somewhat possible

Named arguments, named return values

Return variables you declare with a name in function signatures will be available in function body

            func fooBar(numbers []float64) (processedNumbers []float64){
              // Do some stuff to numbers
              // fill the processedNumbers array
              // but no need to declare it, b/c it's in the signature
              return processedNumbers
            }
            

Return more than one value

            func caller(){
              someNums := []float64{1.2, 3.14, 2.71}
              result, err := calledFooBar(someNums)
              if err != nil {
                // do some error stuff
              }
              for _, x := range result {
                fmt.Println("The numbers are:", x)
              } 
            }
      
            func calledFooBar(numbers []float64) (ezNum int, err error){
              // Do some stuff to numbers
              return ezNum, err
            }