Fix last lectures

Author: s-macke

docs/06-Pure-Functional-Programming-with-Haskell.slide

@@ -175,6 +175,11 @@ Here, the function *add* takes two arguments *a* and *b* and returns *a* + *b*
   add a b = a + b
   main = print( (add 1) 2)
 
+* The return function
+
+TODO
+
+
 * Haskell: Type signatures
 
     add :: Int -> Int -> Int

docs/07-Concurrent-Programming.slide

@@ -17,7 +17,8 @@ https://www.qaware.de
 * Why Concurrent Programming?
 - Computer clock rates do not get higher anymore (since 2004!)
 - But Moores Law is still valid (Multicore!)
-.image img/06-moores-law.png 450 800
+
+.image ./img/06-moores-law.webp 450 _
 
 : https://github.com/qaware/cloudcomputing
 
@@ -218,10 +219,14 @@ What will be the result?
 
 - Atomics either use a atomic CPU feature or perform a low level blocking operation via a mutex
 
-* Waitgroups
+* Waitgroups (using global variableI)
 
 .play ../src/concurrent/waitgroup/parallel_for_loop.go /func/,
 
+* Waitgroups  (using functional programming)
+
+.play ../src/concurrent/waitgroup2/parallel_for_loop.go /func/,
+
 * Excercise
 
 This is the previous code for atomic counting.

docs/Details-semester-work.slide

@@ -6,14 +6,12 @@ import (
 	"sync"
 )
 
+var wg sync.WaitGroup
+
 func ParallelFor(n int, f func(int)) {
-	var wg sync.WaitGroup
 	wg.Add(n)
 	for i := 0; i < n; i++ {
-		go func(i int) {
-			defer wg.Done()
-			f(i)
-		}(i)
+		go f(i)
 	}
 	wg.Wait()
 }
@@ -22,6 +20,7 @@ func ProbablyPrime(value int) {
 	if big.NewInt(int64(value)).ProbablyPrime(0) == true {
 		fmt.Printf("%d is probably prime\n", value)
 	}
+	wg.Done()
 }
 
 func main() {

docs/img/06-moores-law.webp

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"math/big"
+	"sync"
+)
+
+func ParallelFor(n int, f func(int)) {
+	var wg sync.WaitGroup
+	wg.Add(n)
+	for i := 0; i < n; i++ {
+		go func(i int) {
+			defer wg.Done() // is always called before the goroutine exits
+			f(i)
+		}(i)
+	}
+	wg.Wait()
+}
+
+func ProbablyPrime(value int) {
+	if big.NewInt(int64(value)).ProbablyPrime(0) == true {
+		fmt.Printf("%d is probably prime\n", value)
+	}
+}
+
+func main() {
+	fmt.Println("Start Program")
+	ParallelFor(1000, ProbablyPrime)
+	fmt.Println("Stop Program")
+}

src/concurrent/waitgroup/parallel_for_loop.go

@@ -20,13 +20,12 @@ status guess secret | guess == secret = do
                                   return False
 
 play :: Int -> IO ()
-play (-1) = return ()
 play secret = do
     input <- getLine
     let guess = read input :: Int
     isWin <- Main.status guess secret
     if isWin then
-        play (-1)
+        return ()
     else do
         play secret