@@ -0,0 +1,48 @@ 
   
    
     
     
  
    -  Installation: 
 
    
     
     
  
    1- Explain how Go path works?  
 
    
     
     
  
    2- What are the benefits of Go Module (reference its commands)?  
 
    
     
     
  
     
 
    
     
     
  
    -  Concurrency: 
 
    
     
     
  
    1- Explain Concurrency & when to use it?  
 
    
     
     
  
    2- How would you allow communication between goroutines in Go?  
 
    
     
     
  
    3- How would you manage their access to resources?  
 
    
     
     
  
     
 
    
     
     
  
    1 .  why do you use Go (my answer was as simple as "why i shouldn't", and some extra points Grimacing face) 
 
    
     
     
  
    2 .  which libraries I use for development (almost always using the std library 
 
    
     
     
  
    3 .  error handling 
 
    
     
     
  
    4 .  testing (testing techniques, benchmark testing) 
 
    
     
     
  
    5 .  logging (whether using in app logging or sending logs to external service) 
 
    
     
     
  
    6 .  concurrency patterns. 
 
    
     
     
  
    7 .  monitoring (this is tend to be generic not specific to go) 
 
    
     
     
  
    8 .  internal services communications (REST, gRPC, and/or Event Bus). 
 
    
     
     
  
    9 .  MicroServices Architectures (this tend to be a generic not specific to go), which one I use the most? 
 
    
     
     
  
    10 .  in case of using net/http. how to handle http methods, path parameters? 
 
    
     
     
  
     
 
    
     
     
  
    -  Buffered vs Unbuffered channels 
 
    
     
     
  
    -  What is a go routine 
 
    
     
     
  
    -  Fix a Deadlock in a code snippet 
 
    
     
     
  
    -  Implement a map allowing concurrent access 
 
    
     
     
  
    -  Compare emojis represented using runes and strings (I don’t recall this very well) 
 
    
     
     
  
    -  How would you implement rate limiting 
 
    
     
     
  
     
 
    
     
     
  
    -  Why are go routines so cheap when compared to normal threads? 
 
    
     
     
  
    -  What’s is the difference between concurrency and parallelism? 
 
    
     
     
  
    -  How Go’s garbage collection works? 
 
    
     
     
  
     
 
    
     
     
  
    The one interesting thing I can think of is that   
 
    
     
     
  
    I was once asked about how to use channels as a work control mechanism  
 
    
     
     
  
     (like for/select, or separately the quitChan pattern)  
 
    
     
     
  
     
 
    
     
     
  
    1 .  What is the difference between goroutine and os thread? 
 
    
     
     
  
    2 .  How Go GC works? 
 
    
     
     
  
     
 
    
     
     
  
    1 .  What is goroutines 
 
    
     
     
  
    2 .  How goroutines works 
 
    
     
     
  
    3 .  What is channel and how it works 
 
    
     
     
  
    4 .  What is the hardest about Go in your opinion 
 
    
     
     
  
     
 
    
     
     
  
    1 .  Difference between Dep and GoMod 
 
    
     
     
  
    2 .  Why does an empty interface can be used for all types ?  
 
    
     
     
  
    3 .  Why is go’s memory footprint considerably less than Java’s ? 
 
    
     
     
  
    4 .  Best practises when dealing with goroutines ?  
 
    
     
     
  
    5 .  Go’s GC.