add more details and examples to the introduction

concepts/strings/.meta/config.json

@@ -1,5 +1,5 @@
 {
   "blurb": "A string in Go is an immutable sequence of bytes, which don't necessarily have to represent characters.",
   "authors": ["tehsphinx", "erikschierboom"],
-  "contributors": []
+  "contributors": ["kekimaker"]
 }

concepts/strings/about.md

@@ -4,11 +4,36 @@ A `string` in Go is an immutable sequence of bytes, which don't necessarily have
 
 A string literal is defined between double quotes:
 
+
 ```go
 const name = "Jane"
 ```
 
-Some values need to be escaped:
+Strings can be concatenated via the `+` operator:
+
+```go
+
+fullName := "Jane" + " " + "Austen"
+// "Jane Austen"
+```
+
+The `strings` package contains many useful functions to work on strings.
+For more information about string functions, check out the [strings package documentation](https://pkg.go.dev/strings).
+Here are some examples:
+
+```go
+import "strings"
+
+// strings.ToLower returns the string given as argument with all its characters lowercased
+strings.ToLower("MaKEmeLoweRCase")
+// "makemelowercase"
+
+// strings.Repeat returns a string with a substring given as argument repeated many times
+strings.Repeat("Go", 3)
+// "GoGoGo" 
+```
+
+Some special characters need to be escaped with a leading backslash:
 
 | Value | Description          |
 | ----- | -------------------- |
@@ -24,14 +49,45 @@ Some values need to be escaped:
 | `\"`  | Double quote         |
 
 ```go
-const daltons = "Joe\nWilliam\nJack\nAverell"
+fmt.Println("Joe\nWilliam\nJack\nAverell") 
+
+// Output:
+// Joe
+// William
+// Jack
+// Averell
 ```
 
-Raw string literals use backticks (\`) as their delimiter instead of double quotes and are interpreted literally, meaning that there is no need to escape characters or newlines.
+## Raw string literals
+
+Raw string literals use backticks (\`) as their delimiter instead of double quotes and all characters in it are interpreted literally, meaning that there is no need to escape characters or newlines.
+
+This is an example of a multiline string:
 
 ```go
 const daltons = `Joe
 William
 Jack
 Averell`
 ```
+
+This string has multiple lines. More specifically, it has 3 `\n`. However, because we are a raw string literal, we don't need to put the `\n` explicitly in the string. The newlines will be interpreted literally.
+
+Here are some other examples comparing raw string literals with regular string literals:
+
+```go
+`abc`
+// same as "abc"
+
+"\"" // regular string literal with 1 character: a double quote
+// same as `"` a raw string literal with 1 character: a double quote
+
+`\n
+` // raw string literal with 3 character: a backslash, an 'n', and a newline
+// same as "\\n\n"  a regular string literal with 3 characters: a backslash, an 'n', and a newline
+
+"\t\n" // regular string literal with 2 characters: a tab and a newline
+`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'
+```
+
+

concepts/strings/introduction.md

@@ -2,20 +2,40 @@
 
 A `string` in Go is an immutable sequence of bytes, which don't necessarily have to represent characters.
 
-A `string` literal is a sequence of bytes enclosed in double quotes:
+A string literal is defined between double quotes:
+
 
 ```go
-name := "Jane"
+const name = "Jane"
 ```
-
 Strings can be concatenated via the `+` operator:
 
 ```go
+
 fullName := "Jane" + " " + "Austen"
+// "Jane Austen"
 ```
 
-Some special characters need to be escaped with a leading backslash:
+Some special characters need to be escaped with a leading backslash, such as `\t` for a tab and `\n` for a new line in strings.
 
 ```go
-question := "\t or spaces?"
+Dialogue := "How is the weather today?\nIt's sunny"  
+// "How is the weather today?
+// It's sunny"  
+```
+
+The `strings` package contains many useful functions to work on strings.
+For more information about string functions, check out the [strings package documentation](https://pkg.go.dev/strings).
+Here are some examples:
+
+```go
+import "strings"
+
+// strings.ToLower returns the string given as argument with all its characters lowercased
+strings.ToLower("MaKEmeLoweRCase")
+// "makemelowercase"
+
+// strings.Repeat returns a string with a substring given as argument repeated many times
+strings.Repeat("Go", 3)
+// "GoGoGo"
 ```

exercises/concept/welcome-to-tech-palace/.docs/introduction.md

@@ -2,28 +2,39 @@
 
 A `string` in Go is an immutable sequence of bytes, which don't necessarily have to represent characters.
 
-A `string` literal is a sequence of bytes enclosed in double quotes:
+A string literal is defined between double quotes:
 
 ```go
-firstName := "Jane"
+const name = "Jane"
 ```
 
 Strings can be concatenated via the `+` operator:
 
 ```go
 fullName := "Jane" + " " + "Austen"
+// "Jane Austen"
 ```
 
-Some special characters need to be escaped with a leading backslash:
+Some special characters need to be escaped with a leading backslash, such as `\t` for a tab and `\n` for a new line in strings.
 
 ```go
-question := "\t or spaces?"
+Dialogue := "How is the weather today?\nIt's sunny"  
+// "How is the weather today?
+// It's sunny"
 ```
 
 The `strings` package contains many useful functions to work on strings.
+For more information about string functions, check out the [strings package documentation](https://pkg.go.dev/strings).
+Here are some examples:
 
 ```go
 import "strings"
 
-strings.ToLower("TEST") // Output: "test"
+// strings.ToLower returns the string given as argument with all its characters lowercased
+strings.ToLower("MaKEmeLoweRCase")
+// "makemelowercase"
+
+// strings.Repeat returns a string with a substring given as argument repeated many times
+strings.Repeat("Go", 3)
+// "GoGoGo"
 ```

exercises/concept/welcome-to-tech-palace/.meta/config.json

@@ -5,6 +5,7 @@
     "junedev"
   ],
   "contributors": [
+    "kekimaker"
   ],
   "files": {
     "solution": [