diff --git a/LectureCodeExamples/HTTP/cookies/example_01/main.go b/LectureCodeExamples/HTTP/cookies/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..645374ad489582755d7df72322bc62f6555ff5a5
--- /dev/null
+++ b/LectureCodeExamples/HTTP/cookies/example_01/main.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "strconv"
+ "time"
+)
+
+func cookieSetter(w http.ResponseWriter, r *http.Request) {
+ counter, err := r.Cookie("counter")
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ return
+ }
+ value, err := strconv.Atoi(counter.Value)
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ return
+ }
+ value = value + 1
+ newCookie := http.Cookie{
+ Name: "counter",
+ Value: strconv.Itoa(value),
+ }
+ http.SetCookie(w, &newCookie)
+ w.WriteHeader(http.StatusOK)
+ return
+}
+
+func main() {
+ http.HandleFunc("/cookie", cookieSetter)
+ go http.ListenAndServe(":8090", nil)
+
+ url := "http://:8090/cookie"
+ req, err := http.NewRequest("GET",url,nil)
+ if err != nil {
+ panic(err)
+ }
+
+ client := http.Client{}
+
+ c := http.Cookie{
+ Name:"counter", Value:"1", Domain: "127.0.0.1",
+ Path: "/", Expires: time.Now().AddDate(1,0,0)}
+ req.AddCookie(&c)
+
+ fmt.Println("-->", req.Header)
+
+ resp, err := client.Do(req)
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println("<--",resp.Header)
+}
diff --git a/LectureCodeExamples/HTTP/cookies/example_02/main.go b/LectureCodeExamples/HTTP/cookies/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..b68e1ba136d3683b2713b4a4189791befa130669
--- /dev/null
+++ b/LectureCodeExamples/HTTP/cookies/example_02/main.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/cookiejar"
+ url2 "net/url"
+ "strconv"
+)
+
+func cookieSetter(w http.ResponseWriter, r *http.Request) {
+ counter, err := r.Cookie("counter")
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ return
+ }
+ value, err := strconv.Atoi(counter.Value)
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ return
+ }
+ value = value + 1
+ newCookie := http.Cookie{
+ Name: "counter",
+ Value: strconv.Itoa(value),
+ }
+ http.SetCookie(w, &newCookie)
+ w.WriteHeader(http.StatusOK)
+}
+
+func main() {
+ http.HandleFunc("/cookie", cookieSetter)
+ go http.ListenAndServe(":8090", nil)
+
+ jar, err := cookiejar.New(nil)
+ if err != nil {
+ panic(err)
+ }
+ cookies := []*http.Cookie{
+ &http.Cookie{Name:"counter",Value:"1"},
+ }
+
+ url := "http://localhost:8090/cookie"
+ u, _ := url2.Parse(url)
+ jar.SetCookies(u, cookies)
+
+ client := http.Client{Jar: jar}
+
+ for i:=0; i<5; i++ {
+ _, err := client.Get(url)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("Client cookie",jar.Cookies(u))
+ }
+}
diff --git a/LectureCodeExamples/HTTP/middleware/example_01/main b/LectureCodeExamples/HTTP/middleware/example_01/main
new file mode 100644
index 0000000000000000000000000000000000000000..0d9736fd258ba2f6a682ea8ed76895d870196159
Binary files /dev/null and b/LectureCodeExamples/HTTP/middleware/example_01/main differ
diff --git a/LectureCodeExamples/HTTP/middleware/example_01/main.go b/LectureCodeExamples/HTTP/middleware/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..613ad3d5f1b25d59499c15ba1e2204b6d901ba61
--- /dev/null
+++ b/LectureCodeExamples/HTTP/middleware/example_01/main.go
@@ -0,0 +1,49 @@
+package main
+
+import (
+ "encoding/base64"
+ "net/http"
+ "strings"
+ "fmt"
+)
+
+type MyHandler struct{}
+
+func (mh *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request){
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(`{"message": "Perfect!!!"}`))
+ return
+}
+
+func AuthMiddleware(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
+ header := r.Header.Get("Authorization")
+ if header == "" {
+ w.WriteHeader(http.StatusUnauthorized)
+ return
+ }
+
+ authType := strings.Split(header," ")
+ fmt.Println(authType)
+ fmt.Println(r)
+ if len(authType) != 2 || authType[0] != "Basic" {
+ w.WriteHeader(http.StatusUnauthorized)
+ return
+ }
+ credentials,err := base64.StdEncoding.DecodeString(authType[1])
+ if err != nil {
+ w.WriteHeader(http.StatusUnauthorized)
+ return
+ }
+ if string(credentials) == "Open Sesame" {
+ next.ServeHTTP(w, r)
+ }
+ })
+}
+
+func main() {
+ targetHandler := MyHandler{}
+ http.Handle("/authenticate", AuthMiddleware(&targetHandler))
+ fmt.Println("Starting server on port 8090")
+ panic(http.ListenAndServe(":8090", AuthMiddleware(&targetHandler)))
+}
diff --git a/LectureCodeExamples/HTTP/middleware/example_01/server b/LectureCodeExamples/HTTP/middleware/example_01/server
new file mode 100644
index 0000000000000000000000000000000000000000..30f4fe5f5774170c98660245ad645cca94fc79c9
Binary files /dev/null and b/LectureCodeExamples/HTTP/middleware/example_01/server differ
diff --git a/LectureCodeExamples/HTTP/middleware/example_02/main b/LectureCodeExamples/HTTP/middleware/example_02/main
new file mode 100644
index 0000000000000000000000000000000000000000..2b3a5fe4d488eada00853163869c9d8f3d6d77de
Binary files /dev/null and b/LectureCodeExamples/HTTP/middleware/example_02/main differ
diff --git a/LectureCodeExamples/HTTP/middleware/example_02/main.go b/LectureCodeExamples/HTTP/middleware/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..200dfc9b3e9e1649227fecee0ff71af5bbfc8441
--- /dev/null
+++ b/LectureCodeExamples/HTTP/middleware/example_02/main.go
@@ -0,0 +1,45 @@
+package main
+
+import "net/http"
+
+type MyHandler struct{}
+
+func (mh *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request){
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(`{"message": "Perfect!!!"}`))
+ return
+}
+
+type Middleware func(http.Handler) http.Handler
+
+func ApplyMiddleware(h http.Handler, middleware ... Middleware) http.Handler {
+ for _, next := range middleware {
+ h = next(h)
+ }
+ return h
+}
+
+func SimpleMiddleware(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
+ value := w.Header().Get("simple")
+ if value == "" {
+ value = "X"
+ } else {
+ value = value + "X"
+ }
+ w.Header().Set("simple", value)
+ next.ServeHTTP(w,r)
+ })
+}
+
+func main() {
+
+ h := &MyHandler{}
+
+ http.Handle("/three", ApplyMiddleware(
+ h, SimpleMiddleware, SimpleMiddleware, SimpleMiddleware))
+ http.Handle("/one", ApplyMiddleware(
+ h, SimpleMiddleware))
+
+ panic(http.ListenAndServe(":8090", nil))
+}
diff --git a/LectureCodeExamples/HTTP/middleware/example_03/main.go b/LectureCodeExamples/HTTP/middleware/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..e154189757bc808f452373ce4e8c3a286fdd50f0
--- /dev/null
+++ b/LectureCodeExamples/HTTP/middleware/example_03/main.go
@@ -0,0 +1,59 @@
+package main
+
+import ("net/http"
+"encoding/base64"
+"strings"
+"fmt"
+)
+type MyHandler struct{}
+
+func (mh *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request){
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte("Perfect!!!"))
+ return
+}
+
+type Middleware func(http.Handler) http.Handler
+
+func ApplyMiddleware(h http.Handler, middleware ... Middleware) http.Handler {
+ for _, next := range middleware {
+ h = next(h)
+ }
+ return h
+}
+
+func AuthMiddleware(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
+ header := r.Header.Get("Authorization")
+ if header == "" {
+ w.WriteHeader(http.StatusUnauthorized)
+ return
+ }
+
+ authType := strings.Split(header," ")
+ fmt.Println(authType)
+ fmt.Println(r)
+ if len(authType) != 2 || authType[0] != "Basic" {
+ w.WriteHeader(http.StatusUnauthorized)
+ return
+ }
+ credentials,err := base64.StdEncoding.DecodeString(authType[1])
+ if err != nil {
+ w.WriteHeader(http.StatusUnauthorized)
+ return
+ }
+ if string(credentials) == "Open Sesame" {
+ next.ServeHTTP(w, r)
+ }
+ })
+}
+
+func main() {
+
+ h := &MyHandler{}
+
+ http.Handle("/authenticate", ApplyMiddleware(
+ h, AuthMiddleware))
+
+ panic(http.ListenAndServe(":8090", nil))
+}
diff --git a/LectureCodeExamples/HTTP/requests/example_01/main b/LectureCodeExamples/HTTP/requests/example_01/main
new file mode 100644
index 0000000000000000000000000000000000000000..3f9772b3e5eb75e3df40800b4815f8b6b73e7a05
Binary files /dev/null and b/LectureCodeExamples/HTTP/requests/example_01/main differ
diff --git a/LectureCodeExamples/HTTP/requests/example_01/main.go b/LectureCodeExamples/HTTP/requests/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..088ce59e4149d75d64735bf3fbea6a97fe91bdfb
--- /dev/null
+++ b/LectureCodeExamples/HTTP/requests/example_01/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net/http"
+)
+
+func main() {
+
+ //resp, err := http.Get("https://httpbin.org/get")
+ resp, err := http.Get("http://localhost:8090/info")
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(resp.Status)
+ fmt.Println(resp.Header["Content-Type"])
+
+ defer resp.Body.Close()
+ buf := bufio.NewScanner(resp.Body)
+
+ for buf.Scan() {
+ fmt.Println(buf.Text())
+ }
+}
diff --git a/LectureCodeExamples/HTTP/requests/example_02/main.go b/LectureCodeExamples/HTTP/requests/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..624eec956289ba273dbbd87d5afd2411c029e9e3
--- /dev/null
+++ b/LectureCodeExamples/HTTP/requests/example_02/main.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "net/http"
+)
+
+func main() {
+ bodyRequest := []byte(`{"user": "john","email":"john@gmail.com"}`)
+ bufferBody := bytes.NewBuffer(bodyRequest)
+
+ url := "https://httpbin.org/post"
+
+ resp, err := http.Post(url, "application/json", bufferBody)
+ if err != nil {
+ panic(err)
+ }
+ defer resp.Body.Close()
+
+ fmt.Println(resp.Status)
+ bodyAnswer := bufio.NewScanner(resp.Body)
+ for bodyAnswer.Scan() {
+ fmt.Println(bodyAnswer.Text())
+ }
+}
diff --git a/LectureCodeExamples/HTTP/requests/example_02a/main.go b/LectureCodeExamples/HTTP/requests/example_02a/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..bee3fbda611abc3adaa988b58d8ada301c0c6e7d
--- /dev/null
+++ b/LectureCodeExamples/HTTP/requests/example_02a/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "net/http"
+ "net/url"
+)
+
+func main() {
+
+ target := "https://httpbin.org/post"
+
+ resp, err := http.PostForm(target,
+ url.Values{"user": {"john"}, "email": {"john@gmail.com"}})
+ if err != nil {
+ panic(err)
+ }
+ defer resp.Body.Close()
+
+ fmt.Println(resp.Status)
+ bodyAnswer := bufio.NewScanner(resp.Body)
+ for bodyAnswer.Scan() {
+ fmt.Println(bodyAnswer.Text())
+ }
+}
diff --git a/LectureCodeExamples/HTTP/requests/example_03/main.go b/LectureCodeExamples/HTTP/requests/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..34b7ad6f13f2e783f0cf943f183a8576bb412a2e
--- /dev/null
+++ b/LectureCodeExamples/HTTP/requests/example_03/main.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "net/http"
+ "time"
+)
+
+func main() {
+ bodyRequest := []byte(`{"user": "john","email":"john@gmail.com"}`)
+ bufferBody := bytes.NewBuffer(bodyRequest)
+
+ url := "https://httpbin.org/put"
+
+ header := http.Header{}
+ header.Add("Content-type", "application/json")
+ header.Add("X-Custom-Header", "somevalue")
+ header.Add("User-Agent", "safe-the-world-with-go")
+
+ req, err := http.NewRequest(http.MethodPut, url, bufferBody)
+
+ if err != nil {
+ panic(err)
+ }
+
+ req.Header = header
+
+ client := http.Client{
+ Timeout: time.Second * 10,
+ }
+
+ resp, err := client.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ defer resp.Body.Close()
+
+ fmt.Println(resp.Status)
+ bodyAnswer := bufio.NewScanner(resp.Body)
+ for bodyAnswer.Scan() {
+ fmt.Println(bodyAnswer.Text())
+ }
+}
diff --git a/LectureCodeExamples/HTTP/server/example_01/main b/LectureCodeExamples/HTTP/server/example_01/main
new file mode 100644
index 0000000000000000000000000000000000000000..d3079540554bd5c7d3161efc7bcd480f12d2c1d2
Binary files /dev/null and b/LectureCodeExamples/HTTP/server/example_01/main differ
diff --git a/LectureCodeExamples/HTTP/server/example_01/main.go b/LectureCodeExamples/HTTP/server/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..e03a4365e195902f6e05569cb72bce5200ddd933
--- /dev/null
+++ b/LectureCodeExamples/HTTP/server/example_01/main.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+ "fmt"
+ "net/http"
+)
+
+func info(w http.ResponseWriter, r *http.Request){
+ for name, headers := range r.Header {
+ fmt.Println(name,headers)
+ }
+ w.Write([]byte(`{"answer": "Perfect!!!"}`))
+ return
+}
+
+func main() {
+
+ http.HandleFunc("/info", info)
+ panic(http.ListenAndServe(":8090", nil))
+}
+
+
diff --git a/LectureCodeExamples/HTTP/server/example_02/main.go b/LectureCodeExamples/HTTP/server/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..5609bfb511b3a745040173d0e1350c059c59b907
--- /dev/null
+++ b/LectureCodeExamples/HTTP/server/example_02/main.go
@@ -0,0 +1,25 @@
+package main
+
+import (
+ "net/http"
+)
+
+type MyHandler struct {}
+
+func(c *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ switch r.RequestURI {
+ case "/hello":
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte("goodbye\n"))
+ case "/goodbye":
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte("hello\n"))
+ default:
+ w.WriteHeader(http.StatusBadRequest)
+ }
+}
+
+func main() {
+ handler := MyHandler{}
+ panic(http.ListenAndServe(":8090", &handler))
+}
diff --git a/LectureCodeExamples/HTTP/server/example_03/main.go b/LectureCodeExamples/HTTP/server/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..2f919eea960cab6c9f27dfbe7b3ab26babd1a251
--- /dev/null
+++ b/LectureCodeExamples/HTTP/server/example_03/main.go
@@ -0,0 +1,47 @@
+package main
+
+import (
+ "log"
+ "net/http"
+)
+
+func apiResponse(w http.ResponseWriter, r *http.Request) {
+ // Set the return Content-Type as JSON
+ w.Header().Set("Content-Type", "application/json")
+ log.Println(r.RequestURI)
+ // Change the response depending on the method being requested
+ switch r.Method {
+ case "GET":
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(`{"message": "GET method requested"}`))
+ case "POST":
+ w.WriteHeader(http.StatusCreated)
+ w.Write([]byte(`{"message": "POST method requested"}`))
+ default:
+ w.WriteHeader(http.StatusNotFound)
+ w.Write([]byte(`{"message": "Can't find method requested"}`))
+ }
+}
+
+func todoApiResponse(w http.ResponseWriter, r *http.Request) {
+ // Set the return Content-Type as JSON
+ w.Header().Set("Content-Type", "application/json")
+ log.Println(r.RequestURI)
+ // Change the response depending on the method being requested
+ switch r.Method {
+ case "GET":
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(`{"message": "GET method for todo requested"}`))
+ case "POST":
+ w.WriteHeader(http.StatusCreated)
+ w.Write([]byte(`{"message": "POST method for todo requested"}`))
+ default:
+ w.WriteHeader(http.StatusNotFound)
+ w.Write([]byte(`{"message": "Can't find todo method requested"}`))
+ }
+}
+func main() {
+ http.HandleFunc("/",apiResponse)
+ http.HandleFunc("/todos",todoApiResponse)
+ log.Fatal(http.ListenAndServe(":8090",nil))
+}
\ No newline at end of file
diff --git a/LectureCodeExamples/HTTP/server/example_03/server b/LectureCodeExamples/HTTP/server/example_03/server
new file mode 100644
index 0000000000000000000000000000000000000000..523c81f6f6e56ea39ad32aae520a3f1d9b4d6246
Binary files /dev/null and b/LectureCodeExamples/HTTP/server/example_03/server differ
diff --git a/LectureCodeExamples/data_transfer_encodings/csv/example_01/main.go b/LectureCodeExamples/data_transfer_encodings/csv/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..de97b2a445a2019069f4894697a9d3047ca67b2e
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/csv/example_01/main.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+ "encoding/csv"
+ "fmt"
+ "io"
+ "log"
+ "strings"
+)
+
+
+func main() {
+ in := `user_id,score,password
+"Gopher",1000,"admin"
+"BigJ",10,"1234"
+"GGBoom",,"1111"
+`
+ r := csv.NewReader(strings.NewReader(in))
+
+ for {
+ record, err := r.Read()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Println(record)
+ }
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/csv/example_02/main.go b/LectureCodeExamples/data_transfer_encodings/csv/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..b6df13e2a678f80081d4ee1be6f291ff3aa80cdc
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/csv/example_02/main.go
@@ -0,0 +1,25 @@
+package main
+
+import (
+ "encoding/csv"
+ "os"
+)
+
+func main() {
+ out := [][]string{
+ {"user_id","score","password"},
+ {"Gopher","1000","admin"},
+ {"BigJ","10","1234"},
+ {"GGBoom","","1111"},
+ }
+ writer := csv.NewWriter(os.Stdout)
+ for _, rec := range out {
+ err := writer.Write(rec)
+ if err != nil {
+ panic(err)
+ }
+ }
+ writer.Flush()
+
+}
+
diff --git a/LectureCodeExamples/data_transfer_encodings/json/example_01/main b/LectureCodeExamples/data_transfer_encodings/json/example_01/main
new file mode 100644
index 0000000000000000000000000000000000000000..acdb31e8da1bdc8a599b583e0f0b44eeb52462fb
Binary files /dev/null and b/LectureCodeExamples/data_transfer_encodings/json/example_01/main differ
diff --git a/LectureCodeExamples/data_transfer_encodings/json/example_01/main.go b/LectureCodeExamples/data_transfer_encodings/json/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..c9bec870d4eb8fa8ac26fb51014ba9c80562f5a2
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/json/example_01/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+"encoding/json"
+"fmt"
+)
+
+func main() {
+ number, err := json.Marshal(42)
+ if err!=nil{
+ panic(err)
+ }
+ fmt.Println(string(number))
+
+ float, _ := json.Marshal(3.14)
+ fmt.Println(string(float))
+
+ msg, _ := json.Marshal("This is a msg!!!")
+ fmt.Println(string(msg))
+
+ numbers, _ := json.Marshal([]int{1,1,2,3,5,8})
+ fmt.Println(string(numbers))
+
+ aMap, _ := json.Marshal(map[string]int{"one":1,"two":2})
+ fmt.Println(string(aMap))
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/json/example_02/main.go b/LectureCodeExamples/data_transfer_encodings/json/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..4dc2755e46c742aefcef5f0b189595bd10878a6c
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/json/example_02/main.go
@@ -0,0 +1,28 @@
+package main
+
+import (
+"encoding/json"
+"fmt"
+)
+
+func main() {
+
+ aNumber, _ := json.Marshal(42)
+
+ var recoveredNumber int = -1
+ err := json.Unmarshal(aNumber, &recoveredNumber)
+ if err!= nil {
+ panic(err)
+ }
+ fmt.Println(recoveredNumber)
+
+
+ aMap, _ := json.Marshal(map[string]int{"one":1,"two":2})
+
+ recoveredMap := make(map[string]int)
+ err = json.Unmarshal(aMap, &recoveredMap)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(recoveredMap)
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/json/example_03/main.go b/LectureCodeExamples/data_transfer_encodings/json/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..a6b562a19d09e01142af3053d9f10ef4f74a496c
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/json/example_03/main.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+)
+
+type User struct {
+ UserId string `json:"userId,omitempty"`
+ Score int `json:"score,omitempty"`
+ password string `json:"password,omitempty"`
+}
+
+func main() {
+
+ userA := User{"Gopher", 1000, "admin"}
+ userB := User{"BigJ", 10, "1234"}
+ userC := User{UserId: "GGBoom", password: "1111"}
+
+ db := []User{userA, userB, userC}
+ dbJson, err := json.Marshal(&db)
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(string(dbJson))
+
+ var indented bytes.Buffer
+ err = json.Indent(&indented, dbJson,""," ")
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(indented.String())
+
+ var recovered []User
+ err = json.Unmarshal(dbJson, &recovered)
+ if err != nil{
+ panic(err)
+ }
+
+ fmt.Println(recovered)
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/tags/example_01/main.go b/LectureCodeExamples/data_transfer_encodings/tags/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..98dec5e54b060573a506467d78a8621c35758324
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/tags/example_01/main.go
@@ -0,0 +1,92 @@
+package main
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "reflect"
+ "strings"
+)
+
+func Marshal(input interface{}) ([]byte, error) {
+ var buffer bytes.Buffer
+ t := reflect.TypeOf(input)
+ v := reflect.ValueOf(input)
+
+ buffer.WriteString("{")
+ for i:=0;i < t.NumField();i++ {
+ encodedField,err := encodeField(t.Field(i),v.Field(i))
+
+ if err != nil {
+ return nil, err
+ }
+ if len(encodedField) != 0 {
+ if i >0 && i<= t.NumField()-1 {
+ buffer.WriteString(", ")
+ }
+ buffer.WriteString(encodedField)
+ }
+ }
+ buffer.WriteString("}")
+ return buffer.Bytes(),nil
+}
+
+func encodeField(f reflect.StructField, v reflect.Value) (string, error) {
+
+ if f.PkgPath!=""{
+ return "",nil
+ }
+
+ if f.Type.Kind() != reflect.String {
+ return "", nil
+ }
+
+ tag, found := f.Tag.Lookup("pretty")
+ if !found {
+ return "", nil
+ }
+
+ result := f.Name+":"
+ var err error = nil
+ switch tag {
+ case "upper":
+ result = result + strings.ToUpper(v.String())
+ case "lower":
+ result = result + strings.ToLower(v.String())
+ default:
+ err = errors.New("invalid tag value")
+ }
+ if err != nil {
+ return "", err
+ }
+
+ return result, nil
+}
+
+type User struct {
+ UserId string `pretty:"upper"`
+ Email string `pretty:"lower"`
+ password string `pretty:"lower"`
+}
+
+type Record struct {
+ Name string `pretty:"lower" json:"name"`
+ Surname string `pretty:"upper" json:"surname"`
+ Age int `pretty:"other" json:"age"`
+}
+
+
+func main() {
+ u := User{"John", "John@Gmail.com", "admin"}
+
+ marSer, _ := Marshal(u)
+ fmt.Println("pretty user", string(marSer))
+
+ r := Record{"John", "Johnson",33}
+ marRec, _:= Marshal(r)
+ fmt.Println("pretty rec", string(marRec))
+
+ jsonRec, _ := json.Marshal(r)
+ fmt.Println("json rec",string(jsonRec))
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/xml/example_01/main.go b/LectureCodeExamples/data_transfer_encodings/xml/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..03ba15bdaa0ed686c1d930ff72325ac45a404822
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/xml/example_01/main.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+ "encoding/xml"
+ "fmt"
+)
+
+func main() {
+ number, err := xml.Marshal(42)
+ if err!=nil{
+ panic(err)
+ }
+ fmt.Println(string(number))
+
+ float, _ := xml.Marshal(3.14)
+ fmt.Println(string(float))
+
+ msg, _ := xml.Marshal("This is a msg!!!")
+ fmt.Println(string(msg))
+
+ numbers, _ := xml.Marshal([]int{1,2,2,3,5,8})
+ fmt.Println(string(numbers))
+
+ aMap, err := xml.Marshal(map[string]int{"one":1,"two":2})
+ fmt.Println(err)
+ fmt.Println("-",string(aMap),"-")
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/xml/example_02/main.go b/LectureCodeExamples/data_transfer_encodings/xml/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..50cbf5657f0a3f7dc029310db17b1e5becd6eb63
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/xml/example_02/main.go
@@ -0,0 +1,77 @@
+package main
+
+import (
+ "encoding/xml"
+ "errors"
+ "fmt"
+)
+
+type MyMap map[string]string
+
+func (s MyMap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+ tokens := []xml.Token{start}
+
+ for key, value := range s {
+ t := xml.StartElement{Name: xml.Name{"", key}}
+ tokens = append(tokens, t, xml.CharData(value), xml.EndElement{t.Name})
+ }
+
+ tokens = append(tokens, xml.EndElement{start.Name})
+
+ for _, t := range tokens {
+ err := e.EncodeToken(t)
+ if err != nil {
+ return err
+ }
+ }
+
+ return e.Flush()
+}
+
+func (a MyMap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+
+ key := ""
+ val := ""
+
+ for {
+
+ t, _ := d.Token()
+ switch tt := t.(type) {
+
+ case xml.StartElement:
+ key = tt.Name.Local
+ case xml.CharData:
+ val = string(tt)
+ case xml.EndElement:
+ if len(key) != 0{
+ a[key] = val
+ key,val = "", ""
+ }
+ if tt.Name == start.Name {
+ return nil
+ }
+
+ default:
+ return errors.New(fmt.Sprintf("uknown %T",t))
+ }
+ }
+
+ return nil
+}
+
+
+func main() {
+
+ var theMap MyMap = map[string]string{"one": "1","two":"2","three":"3"}
+ aMap, _ := xml.MarshalIndent(&theMap, "", " ")
+ fmt.Println(string(aMap))
+
+ var recoveredMap MyMap = make(map[string]string)
+
+ err := xml.Unmarshal(aMap, &recoveredMap)
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(recoveredMap)
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/xml/example_03/main.go b/LectureCodeExamples/data_transfer_encodings/xml/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..7fa7fc10aee1b2ce793ed0e154ffb14fbe7cedd1
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/xml/example_03/main.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+ "encoding/xml"
+ "fmt"
+)
+
+type User struct {
+ UserId string `xml:"userId,omitempty"`
+ Score int `xml:"score,omitempty"`
+ password string `xml:"password,omitempty"`
+}
+
+type UsersArray struct {
+ Users []User `xml:"users,omitempty"`
+}
+
+func main() {
+
+ userA := User{"Gopher", 1000, "admin"}
+ userB := User{"BigJ", 10, "1234"}
+ userC := User{UserId: "GGBoom", password: "1111"}
+
+ db := UsersArray{[]User{userA, userB, userC}}
+ dbXML, err := xml.Marshal(&db)
+ if err != nil {
+ panic(err)
+ }
+
+ var recovered UsersArray
+ err = xml.Unmarshal(dbXML, &recovered)
+ if err != nil{
+ panic(err)
+ }
+ fmt.Println(recovered)
+
+ var indented []byte
+ indented, err = xml.MarshalIndent(recovered,""," ")
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(string(indented))
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/yaml/example_01/main.go b/LectureCodeExamples/data_transfer_encodings/yaml/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..db2d5ee35c84d1dc01cc8f0df9320ea2795ba78b
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/yaml/example_01/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "gopkg.in/yaml.v2"
+ "fmt"
+)
+
+func main() {
+ number, err := yaml.Marshal(42)
+ if err!=nil{
+ panic(err)
+ }
+ fmt.Println(string(number))
+
+ float, _ := yaml.Marshal(3.14)
+ fmt.Println(string(float))
+
+ msg, _ := yaml.Marshal("This is a msg!!!")
+ fmt.Println(string(msg))
+
+ numbers, _ := yaml.Marshal([]int{1,1,2,3,5,8})
+ fmt.Println(string(numbers))
+
+ aMap, _ := yaml.Marshal(map[string]int{"one":1,"two":2})
+ fmt.Println(string(aMap))
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/yaml/example_02/main.go b/LectureCodeExamples/data_transfer_encodings/yaml/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..7bbd4062d8bd2369f2aaf870142976451d95416d
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/yaml/example_02/main.go
@@ -0,0 +1,28 @@
+package main
+
+import (
+ "fmt"
+ "gopkg.in/yaml.v2"
+)
+
+func main() {
+
+ aNumber, _ := yaml.Marshal(42)
+
+ var recoveredNumber int = -1
+ err := yaml.Unmarshal(aNumber, &recoveredNumber)
+ if err!= nil {
+ panic(err)
+ }
+ fmt.Println(recoveredNumber)
+
+
+ aMap, _ := yaml.Marshal(map[string]int{"one":1,"two":2})
+
+ recoveredMap := make(map[string]int)
+ err = yaml.Unmarshal(aMap, &recoveredMap)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(recoveredMap)
+}
diff --git a/LectureCodeExamples/data_transfer_encodings/yaml/example_03/main.go b/LectureCodeExamples/data_transfer_encodings/yaml/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..1a66e09f3bca6d2ebd8e6bac6db97e741a640b06
--- /dev/null
+++ b/LectureCodeExamples/data_transfer_encodings/yaml/example_03/main.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+ "fmt"
+ "gopkg.in/yaml.v2"
+)
+
+type User struct {
+ UserId string `yaml:"userId,omitempty"`
+ Score int `yaml:"score,omitempty"`
+ password string `yaml:"password,omitempty"`
+}
+
+func main() {
+
+ userA := User{"Gopher", 1000, "admin"}
+ userB := User{"BigJ", 10, "1234"}
+ userC := User{UserId: "GGBoom", password: "1111"}
+
+ db := []User{userA, userB, userC}
+ dbYaml, err := yaml.Marshal(&db)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(string(dbYaml))
+
+ var recovered []User
+ err = yaml.Unmarshal(dbYaml, &recovered)
+ if err != nil{
+ panic(err)
+ }
+ fmt.Println(recovered)
+}
diff --git a/LectureCodeExamples/input_output/files/example_01/main.go b/LectureCodeExamples/input_output/files/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..2e3e79ae65fd2e58234cccc9fd5ed12dbdf29022
--- /dev/null
+++ b/LectureCodeExamples/input_output/files/example_01/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+)
+
+func main() {
+ msg := "Save the world with Go!!!"
+ filePath := "/tmp/msg"
+
+ err := ioutil.WriteFile(filePath,
+ []byte(msg), 0644)
+ if err != nil {
+ panic(err)
+ }
+
+ read, err := ioutil.ReadFile(filePath)
+ if err != nil{
+ panic(err)
+ }
+
+ fmt.Printf("%s\n", read)
+}
diff --git a/LectureCodeExamples/input_output/files/example_02/main.go b/LectureCodeExamples/input_output/files/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..3343aca1bc0022de1f78e0555e2b2f9d56bc4334
--- /dev/null
+++ b/LectureCodeExamples/input_output/files/example_02/main.go
@@ -0,0 +1,21 @@
+package main
+
+import (
+ "os"
+)
+
+func main() {
+ filePath := "/tmp/msg"
+ msg := []string{
+ "Rule", "the", "world", "with", "Go!!!"}
+
+ f, err := os.Create(filePath)
+ if err != nil {
+ panic(err)
+ }
+ defer f.Close()
+
+ for _, s := range msg {
+ f.WriteString(s+"\n")
+ }
+}
diff --git a/LectureCodeExamples/input_output/files/example_03/main.go b/LectureCodeExamples/input_output/files/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d22c7e46661860dae940cc2bfa560aefeed02d4
--- /dev/null
+++ b/LectureCodeExamples/input_output/files/example_03/main.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+ "fmt"
+ "os"
+)
+
+func main() {
+ tmp := os.TempDir()
+ file, err := os.Create(tmp+"/myfile")
+ if err != nil {
+ panic(err)
+ }
+ defer file.Close()
+
+ msg := "Save the world with Go!!!"
+
+ _, err = file.WriteString(msg)
+ if err != nil {
+ panic(err)
+ }
+
+ positions := []int{4, 10, 20}
+ for _, i := range positions {
+ _, err := file.Seek(int64(i),0)
+ if err != nil {
+ panic(err)
+ }
+ file.Write([]byte("X"))
+ }
+ // Reset
+ file.Seek(0,0)
+ // Read the result
+ result := make([]byte,len(msg))
+ _, err = file.Read(result)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Printf("%s\n",result)
+}
diff --git a/LectureCodeExamples/input_output/readers_writers/example_01/main.go b/LectureCodeExamples/input_output/readers_writers/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..9a0c0f7ea636f009e144309b8df864470ac0b362
--- /dev/null
+++ b/LectureCodeExamples/input_output/readers_writers/example_01/main.go
@@ -0,0 +1,48 @@
+package main
+
+import (
+ "errors"
+ "fmt"
+ "io"
+)
+
+type MyReader struct {
+ data string
+ from int
+}
+
+func(r *MyReader) Read(p []byte) (int, error) {
+ if p == nil {
+ return -1, errors.New("nil target array")
+ }
+ if len(r.data) <= 0 || r.from == len(r.data){
+ return 0, io.EOF
+ }
+ n := len(r.data) - r.from
+ if len(p) < n {
+ n = len(p)
+ }
+ for i:=0;i < n; i++ {
+ b := byte(r.data[r.from])
+ p[i] = b
+ r.from++
+ }
+ if r.from == len(r.data) {
+ return n, io.EOF
+ }
+ return n, nil
+}
+
+func main() {
+ target := make([]byte,5)
+ empty := MyReader{}
+ n, err := empty.Read(target)
+ fmt.Printf("Read %d: Error: %v\n",n,err)
+ mr := MyReader{"Save the world with Go!!!",0}
+ n, err = mr.Read(target)
+ for err == nil {
+ fmt.Printf("Read %d: Error: %v -> %s\n",n,err, target)
+ n, err = mr.Read(target)
+ }
+ fmt.Printf("Read %d: Error: %v -> %s\n",n,err, target)
+}
diff --git a/LectureCodeExamples/input_output/readers_writers/example_02/main.go b/LectureCodeExamples/input_output/readers_writers/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..3d1ecaa788d26ecef9afd1aa2af373a8d9fcd830
--- /dev/null
+++ b/LectureCodeExamples/input_output/readers_writers/example_02/main.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+ "errors"
+ "io"
+ "fmt"
+)
+
+type MyWriter struct {
+ data string
+ size int
+}
+
+func (mw *MyWriter) Write(p []byte) (int, error) {
+ if len(p) == 0 {
+ return 0, io.EOF
+ }
+ n := mw.size
+ var err error = nil
+ if len(p) < mw.size {
+ n = len(p)
+ } else {
+ err = errors.New("p larger than size")
+ }
+ mw.data = mw.data + string(p[0:n])
+
+ return n, err
+}
+
+func main() {
+ msg := []byte("the world with Go!!!")
+
+ mw := MyWriter{"Save ",6}
+ i := 0
+ var err error
+ for err == nil && i < len(msg) {
+ n, err := mw.Write(msg[i:])
+ fmt.Printf("Written %d error %v --> %s\n", n, err, mw.data)
+ i = i + n
+ }
+}
diff --git a/LectureCodeExamples/input_output/standard_io/example_01/main.go b/LectureCodeExamples/input_output/standard_io/example_01/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..8a54c31d1d325916cb5606ea47b8fcf99036d009
--- /dev/null
+++ b/LectureCodeExamples/input_output/standard_io/example_01/main.go
@@ -0,0 +1,15 @@
+package main
+
+import (
+ "fmt"
+ "os"
+)
+
+func main() {
+ msg := []byte("Save the world with Go!!!\n")
+ n, err := os.Stdout.Write(msg)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Printf("Written %d characters\n",n)
+}
diff --git a/LectureCodeExamples/input_output/standard_io/example_02/main.go b/LectureCodeExamples/input_output/standard_io/example_02/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b34f1cbbd36c4569a6276b0085c90986a1569f0
--- /dev/null
+++ b/LectureCodeExamples/input_output/standard_io/example_02/main.go
@@ -0,0 +1,17 @@
+package main
+
+import (
+ "fmt"
+ "os"
+ "strings"
+)
+
+func main() {
+ target := make([]byte,50)
+ n, err := os.Stdin.Read(target)
+ if err != nil {
+ panic(err)
+ }
+ msg := string(target[:n])
+ fmt.Println(n,strings.ToUpper(msg))
+}
diff --git a/LectureCodeExamples/input_output/standard_io/example_03/main.go b/LectureCodeExamples/input_output/standard_io/example_03/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..7de7d264705c9a4257fdc354a1e22b5766517608
--- /dev/null
+++ b/LectureCodeExamples/input_output/standard_io/example_03/main.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "os"
+ "strings"
+)
+
+func main() {
+ reader := bufio.NewReader(os.Stdin)
+ fmt.Print(">>> What do you have to say?\n")
+ fmt.Print("<<< ")
+ text, err := reader.ReadString('\n')
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(">>> You're right!!!")
+ fmt.Println(strings.ToUpper(text))
+}
diff --git a/LectureCodeExamples/input_output/standard_io/example_04/main.go b/LectureCodeExamples/input_output/standard_io/example_04/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..0ff584641852e4a2f290e51302ffaac08fe72a92
--- /dev/null
+++ b/LectureCodeExamples/input_output/standard_io/example_04/main.go
@@ -0,0 +1,21 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "os"
+)
+
+func main() {
+ scanner := bufio.NewScanner(os.Stdin)
+ fmt.Println(">>> What do you have to say?\n")
+ counter := 0
+ for scanner.Scan() {
+ text := scanner.Text()
+ counter = counter + len(text)
+ if counter > 15 {
+ break
+ }
+ }
+ fmt.Println("that's enough")
+}
diff --git a/LectureCodeExamples/input_output/standard_io/example_05/main.go b/LectureCodeExamples/input_output/standard_io/example_05/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..40fc05183e135cc22a7f7d58efceb68af62e515f
--- /dev/null
+++ b/LectureCodeExamples/input_output/standard_io/example_05/main.go
@@ -0,0 +1,18 @@
+package main
+
+import (
+ "bufio"
+ "os"
+ "time"
+)
+
+func main() {
+ writer := bufio.NewWriter(os.Stdout)
+
+ msg := "Save the world with Go!!!\n"
+ for _, letter := range msg {
+ time.Sleep(time.Millisecond*300)
+ writer.WriteByte(byte(letter))
+ writer.Flush()
+ }
+}