readme, renames

Author: softchris

01 basics/04 loops/README.md

@@ -1,4 +1,4 @@
-# Boolean logic
+# Go from the beginning - applying boolean logic
 
 > This article will cover working with boolean logic. You will learn how to work with boolean data, `if`, `else if` and `else` constructs.
 

01 basics/05 - user input/README.md

@@ -1,4 +1,4 @@
-# Converting between types
+# Go from the beginning - converting between types
 
 There's different data types and a need to convert between them. For example, we often need to convert between text and numbers for presentational and other reasons. We also need to convert between numbers and decimals without loosing information in the process. 
 
@@ -192,3 +192,7 @@ str := strconv.Itoa(noOfPlayers)
 ## Additional parsing
 
 The `strconv` library is what you want if you start with a string and you want to convert to and from another format. Learn more about [strconv library here](https://pkg.go.dev/strconv)
+
+## Summary
+
+TODO

01 basics/05 - user input/main.go

@@ -0,0 +1,163 @@
+# Go from the beginning - working with loops
+
+> TLDR; this article covers working with loops in Go
+
+You are likely to want repeat a set of instructions. For example, you might have a list of orders where you need to process each order. Or you have a file where you need to read it line by line or there might be some other calculation. Regardless of your situation, you are likely to need a looping construct, so what are your options in Go?
+
+Basically, you are using the `for` loop. There are three major ways yu can use it:
+
+- **increment steps**. With the help of a variable, you define a start point, a condition when to stop and an incrementation step. This is your "classic" for-loop. Here's what it looks like:
+
+   ```go
+   for i := 0; i < 10; i++ {
+     // run these statements
+   } 
+   ```
+
+- while. In many programming languages you a have a `while` keyword. Go doesn't have that, but what you can do is to use the for-loop in a similar way. You omit the initialization step and increment step and get this code:
+
+  ```go
+  for <condition> {
+    // run these statements
+  }
+  ```
+
+- for each. lastly, you have the `for-each` like construct that operates on an array like sequence. It uses the `range` keyword to function:
+
+   ```go
+   for i,s := range array {
+     // run these statements
+   }
+   ```
+
+## The `for` loop
+
+The conventional for-loop has three different parts:
+
+- initialization, here you want to create a variable and assign it a starter value like so:
+
+   ```go
+   for i:= 0;
+   ```
+
+   Note the use of `;`, you usually don's use semicolon, but for this construct, you need it.
+
+- condition. The next step is evaluating whether you should continue incrementing or not. You define a boolean expression here, that if `true`, continues to loop:
+
+   ```go
+   for i := 0; i< 10     
+   ```
+
+   `i < 10`, as long as a value is between 0 and 10 (becomes 10, then loop breaks), then it returns true and the loop continues.
+
+- increment, in this step, the loop variable `i` is updated, updating it by 1 is common but you can add any increment size, negative or positive.
+
+   ```go
+   for i := 0; i< 10; i++ {
+
+   }
+   ``` 
+
+   Here, `i` is updated by 1. This loop will run ten times.
+
+## Repeat until condition is met with `while`
+
+A simplified version of this loop can omit the initialization and increment step. You are then left with the condition step only. This step tests whether a variable is true or false and the loop exits on false. Here's an example:
+
+```go
+i := 1
+for i < 10 {
+  i++
+  // do something
+}
+```
+
+In this case, we are declaring `i` outside of the loop. Within the loop, we need to change the value to something that will make the loop expression evaluate to false or it will loop forever.
+
+Here's another code, using the same idea, but this time we ask for input from the user:
+
+```go
+var keepGoing = true
+ answer := ""
+ for keepGoing {
+  fmt.Println("Type command: ")
+  fmt.Scan(&answer)
+  if answer == "quit" {
+   keepGoing = false
+  }
+ }
+ fmt.Println("program exit")
+```
+
+An example run of the program could look like so:
+
+```bash
+Type command: test
+Type command: something
+Type command: quit
+program exit
+```
+
+## Using `for each` over a range
+
+For this next loop construct, the idea is to operate over an array or some kind of known sequence. For each iteration you are able to get the index as as well as the next item in the loop. Here's some example code:
+
+```go
+arr := []string{"arg1", "arg2", "arg3"}
+ for i, s := range arr {
+  fmt.Printf("index: %d, item: %s \n", i, s)
+ }
+```
+
+`arr` is defined as an array and then the `range` construct is used to loop over the array. For each iteration, the current index is being assigned to `i` and the array item is assigned to `s`. An output of the above code will look like so:
+
+```output
+index: 0, item: arg1
+index: 1, item: arg2
+index: 2, item: arg3
+```
+
+## Controlling the loop with `continue` and `break`
+
+So far, you've seen three ways you can use the `for` construct. There are also ways to control the loop. You can control the loop with the following keywords:
+
+- `break`, this will exit the loop construct
+
+   ```go
+   arr = []int{-1,2}
+   for i := 0; i< 2; i++ {
+     fmt.Println(arr[i])
+     if arr[i] < 0 {
+       break;
+     }
+   }     
+   ```
+
+   The output will be:
+
+   ```output
+   -1
+   ```
+
+   it won't output `2` as the loop exits after the first iteration.
+
+- `continue`, this will move on to the next iteration. If `break` exits the loop, `continue` skips the current iteration:
+
+   ```go
+   arr = []int{-1,2,-1, 3}
+   for i := 0; i< 4; i++ {
+     if arr[i] < 0 {
+       break;
+     }
+     fmt.Println(arr[i])
+   } 
+   ```
+
+   The output will be:
+
+   ```output
+   2
+   3
+   ```
+
+## Summary

01 basics/01 - hello/README.md renamed to 01-basics/01-hello/README.md

@@ -0,0 +1,91 @@
+# Reading user input
+
+It's an important thing to be able to read user input from the console. How to do that is by using the built-in `fmt`.
+
+The `fmt` library has a built-in `Scan()` method.
+
+## Reading one input
+
+You might start out wanting to read one input from the user. That's what the `Scan()` method does by default.
+
+Here's some code showing how to collect user input:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    var response string
+    fmt.Scan(&response)
+    fmt.Println("User typed: ", response)
+}
+```
+
+Not how you send in the string `response` as a reference, using the `&` operator. It's done this way as the `Scan()` method will modify the variable you send in. 
+
+When you run this code, you will see the below output:
+
+```output
+hello # this is what we typed
+User typed: hello
+```
+
+## Reading multiple inputs
+
+You can provide several arguments to the `Scan()` method. By providing several arguments, you can collect more than one user input and separate each input with a comma. Here's how to apply this technique:
+
+```go
+var a1, a2 string
+// multiple input
+fmt.Scan(&a1, &a2)
+
+// formatted string
+str := fmt.Sprintf("a1: %s a2: %s", a1, a2)
+```
+
+Note how `a1` and `a2` is sent into `Scan()` and they are comma separated, so how will those code run?
+
+When you run this code, there's two ways for the user to input. The user can either separate the values by space like so:
+
+```output
+hi you
+a1: hi a2: you
+```
+
+or by newline:
+
+```output
+hi 
+you
+a1: hi a2: you
+```
+
+## Scanf, scan the input with formatters
+
+So far, you've seen how you can collect input with spaces and endlines as separators. You can also be very specific in how you collect input. Imagine that the user wants to type in an invoice number like so "INV200" or "INV114" and what you are interested in is the number part, or maybe you are interested in the prefix as well? The answer to solving this is in the `Scanf()`  function. It takes formatters. With formatters, you're able to pick the part of the user input you are interested in, and place that into the variable you want. 
+
+In the above mentioned case, you can construct code looking like so:
+
+```go
+var prefix string
+var no int
+// in110
+fmt.Scanf("%3s%d", &prefix, &no)
+fmt.Printf("prefix: %s, invoice no: %d", prefix, no)
+```
+
+The interesting part lies in the first argument of `Scanf()`, namely `53s%d`. What the means is, take the first 3 characters, `%3s` and interpret as a string. Then interpret and place the remaining as a number, `%d`. 
+
+Running this program you will get an output like so:
+
+```output
+inv200
+prefix: inv, invoice no: 200
+```
+
+"inv" is placed in `prefix` and 200 in `no` variable.
+
+## Learn more
+
+To learn more about this are, check out this link <https://pkg.go.dev/fmt#Scanf>

01 basics/01 - hello/go.mod renamed to 01-basics/01-hello/go.mod

@@ -0,0 +1,28 @@
+package main
+
+import "fmt"
+
+func main() {
+	// var response string
+	fmt.Println("hi")
+
+	// // one input
+	// fmt.Scan(&response)
+	// fmt.Println("User typed ", response)
+
+	// var a1, a2 string
+
+	// // multiple input
+	// fmt.Scan(&a1, &a2)
+
+	// // formatted string
+	// str := fmt.Sprintf("a1: %s a2: %s", a1, a2)
+	// fmt.Println(str)
+
+	var prefix string
+	var no int
+	// in110
+	fmt.Scanf("%3s%d", &prefix, &no)
+	fmt.Printf("prefix: %s, invoice no: %d", prefix, no)
+
+}

01 basics/01 - hello/main.go renamed to 01-basics/01-hello/main.go

@@ -1,6 +1,6 @@
 # Functions
 
-So far, you've seen the function `main`, define like so:
+So far, you've seen the function `main()`, define like so:
 
 ```go
 func main(){