text: Q:
  
  Does "visible in the caller" mean the stack that invoked the mutating function?
  
  Reading through the Effective Go documentation and I am having a little hard time wrapping my head what the following statement means.
  If you pass a map to a function that changes the contents of the map, the changes will be visible in the caller.
  
  I understand the gist of what this means regarding changes to a reference/pointer would be reflected outside the function itself. What I do not understand is "visible in the caller". Not 100% what this term means. Is the caller the stack that called the function that mutated the map? 
  
  A:
  
  A Go map is a pointer to the underlying data structure, so if you pass a map to a function, you pass the pointer to that map. That means the caller and the called fuction are sharing that instance of the data structure. Any changes done to that structure can be read by other functions, so they are "visible". So if you have:
  func f(m map[string]string,ch chan struct{}) {
     m["x"]="a"
     ch<-struct{}
  }
  
  func g() {
  m:=map[string]string{}
  ch:=make(chan struct{})
  go func() {
     // Do stuff with m
     <-ch
     fmt.Println(m["x"])
  }()
  f(m,ch)
  
  You have one goroutine and f using the same map at the same time, and changes made by f are "visible" in the goroutine. 
  
  