you're doing great

GoesToEleven · GoesToEleven · commit 17a2b6b98e56 · 2017-01-20T09:49:46.000-08:00
diff --git a/22_go-routines/12_channels_pipeline/04_challenge-solution/01_original-solution/main.go b/22_go-routines/12_channels_pipeline/04_challenge-solution/01_original-solution/main.go
diff --git a/22_go-routines/12_channels_pipeline/04_challenge-solution/02_another-solution/main.go b/22_go-routines/12_channels_pipeline/04_challenge-solution/02_another-solution/main.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"sync"
+)
+
+const numFactorials = 100
+const rdLimit = 20
+
+func main() {
+	var w sync.WaitGroup
+	w.Add(numFactorials)
+	factorial(numFactorials, &w)
+	w.Wait()
+
+}
+
+func factorial(n int, wmain *sync.WaitGroup) {
+	var w sync.WaitGroup
+	rand.Seed(42)
+
+	w.Add(n + 1)
+
+	for j := 1; j <= n; j++ {
+
+		go func() {
+			f := rand.Intn(rdLimit)
+			w.Wait()
+			total := 1
+			for i := f; i > 0; i-- {
+
+				total *= i
+			}
+			fmt.Println(f, total)
+			(*wmain).Done()
+			//out <- total
+
+		}()
+		w.Done()
+	}
+	fmt.Println("All done with initialization")
+	w.Done()
+}
diff --git a/22_go-routines/12_channels_pipeline/04_challenge-solution/README.md b/22_go-routines/12_channels_pipeline/04_challenge-solution/README.md
@@ -0,0 +1,42 @@
+A student sent me the below note so I included the student's excellent solution to this project:
+
+Todd, I reviewed your solution to 22_go-routines/04_challenge-solution in your Golang Programming class.
+
+I believe your solution might not run 100 factorial computations concurrently and in parallel as the following statement will calculate the factorials sequentially, since it is receiving them - one by one -  from the pipeline:
+out <- fact(n)
+
+I used the sync package to create a solution that I believe will accomplish your goal. Let me know if I am missing something:
+
+https://github.com/arsanjea/udemyTraining/blob/master/Exercises/exercise38.go
+
+/////
+
+# Definitions
+
+## concurrency
+a design pattern
+go uses goroutines to create concurrent design patterns
+
+## parallelism
+running code from a program on more than one cpu
+parallelism implies you have used concurrent design patterns
+
+## sequentially
+one thing happening after another, in sequence
+
+# here are my thoughts
+
+The original solution uses concurrent design patterns. It uses two different goroutines. The [control flow](https://en.wikipedia.org/wiki/Control_flow) of the program is no longer a straight top-to-bottom sequence. Different goroutines have been launched.
+
+The program may or may not run in parallel. If the program is run on a machine with two or more cpus, the program has the potential to run in parallel. Each of our three goroutines (the two goroutines we launched, and main) could be running on different cpu cores.
+
+Jean-Marc Arsan is correct: the program IS still running sequentially. Even though calculations are occuring in different goroutines, and potentially on different CPU cores, the sequence in which they occur is still sequential. 
+
+goroutines allow synchronization of code.
+
+In this original example, the code is synchronized.
+
+Thank you, Jean-Marc, for your comment on this code!
+
+I appreciate these discussions and hope the notes and your new code sample are helpful to everyone!
+
