CSS 390: Notes from Lecture 6 (DRAFT)

Administrivia

• extension for assignment 2
• new due date for assignment 3 TBA
• feedback received on the course so far: not enough time spent talking about the assignments
  • threw you into the deep end; will spend more time talking about implementation
• goal was to make class achievable with CSS 342 as a prerequisite
  • accept need to recalibrate

The original idea was to spend the bulk of class time discussing core concepts and production systems, with some discussion of implementation in Go. The assignments would cover implementation.

• software development is about managing complexity
• manage complexity by abstraction (divide and conquer, decomposition, interface/implementation, objects/modules)
• these days, complex systems generally means distributed systems
  • vertical scaling: bigger computer
  • horizontal scaling: more computers
• the assignments are designed to build a scale model of a production system
• the Go standard library makes this tractable
• scale model means the assignments point you in the right direction; just keep in mind there's always much, much more to it
  • you still need the rest of the entire CSS program to cover details we're glossing over in this class

Rebooting the course: focus on implementation of the scale model. We'll still discuss general principles and production systems, but it'll be deemphasized.

Make

Simple build shell script:

1. put the shell commands that you would type into the command prompt into a text file (convention: use .sh extension.
2. add #! /bin/bash at beginning of the file to tell the loader that it's a shell script.
3. make the build script executable using chmod command

Make: original build tool from Bell Labs. Long in the tooth, but still useful

VAR = value

target : dependencies...
tabshell commands using $(VAR) is needed

• if any dependency file is newer than the target (or the target does not exist), shell commands are executed (e.g. compile program from sources)
• make performs transitive closure on dependencies to figure out which rules to execute to build which targets
  • avoids rebuilding targets when their dependencies haven't changed
• rules that do not actually build the target file: verbs, e.g.
  • make install
  • make test
  • make clean
• macros and conditional logic for complexity management
• the go command does this for go programs, but a system may be more than just the Go source

Assignment 1

• graded: generally positive, some common issues
  • not using go workspace directory structure (no points off)
    • use go install, not go build or go run
  • not using go fmt (no points off)
  • Not setting 404 status code for not found (1 point off)
  • not using flags (1 point off)
  • some people used templates
    • way beyond the desired scope
    • misses the point of Walmart vs. Snap-on
    • no points deducted for doing the assignment too well
    • anticipates assignment 3

Assignment 2

• was due Tuesday
• late assignments still accepted
• grade of anyone who submitted on time will go up to 11

Concurrency

Because the golang web server handles concurrent requests (even if you're not making concurrent requests in your testing), you need to protect shared memory access.

Everything you need to know about concurrency for the purposes of this course

• concurrent read access by multiple threads (goroutines) is okay
• as soon as some thread writes to a memory location, no other thread may read or write that location until the first write completes
  • read-write or write-write contention leads to unpredictble results and is known as a race condition
  • updating a complex data structure must be protected against concurrent access too (otherwise, partial updates may lead to inconsistent state)
• the sync package provides a Mutex object ("mutual exclusion")
  • Lock the mutex at the beginning of the critical section and Unlock when the section completes
• sync.RWMutex allows multiple concurrent readers, but stops everything for a single write
• the shared map must be protected
• concurrency control is also available using Go's channels which we'll get to later on
• there's much more to concurrency but this is all you need for now

Cookies

I was assuming everone knows what a cookie is. Using a cookie in Go is just a struct and couple of library calls:

1. get the cookie passed in the request object
2. set the cookie in response writer object

Artists' studies are used by artists to figure out smaller pieces of larger scenes. By analogy, when there is a library or feature you don't quite understand, write a small, simple program to test it out. Once you undestand it, you can incorporate it into your program.

You don't get credit on the assignment for doing a cookie study, but a study may help you figure out what you're trying to do

package main

import (
	"fmt"
	"net/http"
	"time"
)

func handler(resp http.ResponseWriter, req *http.Request) {
	oldCookie, err := req.Cookie("name")
	if err != nil {
		fmt.Printf("error getting old cookie: %v\n", err)
	} else {
		fmt.Printf("old cookie: %v\n", oldCookie)
	}
	newCookie := &http.Cookie{
		Name:    "name", // how original
		Value:   "Aries_was_here",
		Expires: time.Now().Add(3 * time.Minute),
	}
	http.SetCookie(resp, newCookie)
	fmt.Fprintf(resp, "cookie: %v", newCookie)
}

func main() {
	http.HandleFunc("/", handler)
	err := http.ListenAndServe(":9191", nil)
	fmt.Printf("ListenAndServe: %v\n", err)
}

curl

The curl command is a handy tool for testing and debugging web sites. It fetches the data without doing any rendering, so you can figure out what's going on. curl -I just fetches the headers.

Assignment 3

Templates

The format argument in the formatted print commands in the fmt package (which are direct descendants of C) is a kind of template.

The Go language provides two templating packages: text/template and html/template. The latter builds on the former, to provide automagic escaping of template parameters. You need to read both pages.

Templates are fairly powerful, including conditionals and loops, but we only need to use fairly limited functionality.

Example 1

Let's do some artists' studies. Start with turning the first example in the html/template into a working program:

package main

import (
	"fmt"
	"html/template"
	"os"
)

const (
	rawText = `{{define "theTemplate"}}Hello, {{.}}!{{end}}`
)

func main() {
	tmpl := template.New("foo")
	tmpl, err := tmpl.Parse(rawText)
	if err != nil {
		fmt.Printf("parsing template: %s\n", err)
		return
	}
	err = tmpl.ExecuteTemplate(os.Stdout, "theTemplate", "Zeus")
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()
}

Hello, Zeus!

Example 2

Figuring out the context argument:

package main

import (
	"fmt"
	"html/template"
	"os"
)

const (
	rawText = `{{define "theTemplate"}}Hello, {{.Nationality}} {{.Kind}}!{{end}}`
)

type Context struct {
	Nationality string
	Kind        string
}

func main() {
	tmpl := template.New("foo")
	tmpl, err := tmpl.Parse(rawText)
	if err != nil {
		fmt.Printf("parsing template: %s\n", err)
		return
	}

	context1 := Context{
		Nationality: "Greek",
		Kind:        "Titans",
	}
	err = tmpl.ExecuteTemplate(os.Stdout, "theTemplate", context1)
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()

	context2 := Context{
		Nationality: "Norse",
		Kind:        "Giants",
	}
	err = tmpl.ExecuteTemplate(os.Stdout, "theTemplate", context2)
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()
}

Hello, Greek Titans!
Hello, Norse Giants!

Example 3

Read the template from a file using the ParseFiles method:

package main

import (
	"fmt"
	"html/template"
	"os"
)

const (
	TemplateFileName = "templates/example03.tmpl"
)

type Context struct {
	Nationality string
	Kind        string
}

func main() {
	tmpl := template.New("foo")
	tmpl, err := tmpl.ParseFiles(TemplateFileName)
	if err != nil {
		fmt.Printf("parsing template: %s\n", err)
		return
	}

	context1 := Context{
		Nationality: "Roman",
		Kind:        "Gods",
	}
	err = tmpl.ExecuteTemplate(os.Stdout, "theTemplate", context1)
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()
}

{{define "theTemplate"}}Hello, {{.Nationality}} {{.Kind}}!{{end}}

Hello, Roman Gods!

Example 4

Read from multiple template files. Note ... turns a slice into a sequence of arguments:

package main

import (
	"fmt"
	"html/template"
	"os"
)

var (
	TemplateFiles = []string{
		"templates/example04.tmpl",
		"templates/example04-body.tmpl",
	}
)

type Context struct {
	Name string
}

func main() {
	tmpl := template.New("foo")
	tmpl, err := tmpl.ParseFiles(TemplateFiles...)
	if err != nil {
		fmt.Printf("parsing template: %s\n", err)
		return
	}

	context1 := Context{
		Name: "Hephaestus",
	}
	err = tmpl.ExecuteTemplate(os.Stdout, "page", context1)
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()
}

templates/example04.tmpl:

{{define "page"}}
<html>
<body>
<p>
{{template "body" .}}
</p>
{{end}}

templates/example04-body.tmpl:

{{define "body"}}Hello, {{.Name}}!{{end}}`

Output:

<html>
<body>
<p>
Hello, Hephaestus!
</p>

Looping

This is overkill for the assignment, but to get carried away:

package main

import (
	"fmt"
	"html/template"
	"os"
)

var (
	TemplateFiles = []string{
		"templates/example05.tmpl",
	}
)

type Context struct {
	Nationality string
	Kind        string
	Names       []string
}

func main() {
	tmpl := template.New("foo")
	tmpl, err := tmpl.ParseFiles(TemplateFiles...)
	if err != nil {
		fmt.Printf("parsing template: %s\n", err)
		return
	}

	context1 := Context{
		Nationality: "Greek",
		Kind:        "Gods",
		Names: []string{
			"Zeus",
			"Ares",
			"Apollo",
			"Hera",
			"Aphordite",
			"Athena",
		},
	}
	err = tmpl.ExecuteTemplate(os.Stdout, "page", context1)
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()

	err = tmpl.ExecuteTemplate(os.Stdout, "name", "Loki")
	if err != nil {
		fmt.Printf("executing template: %s\n", err)
		return
	}
	fmt.Println()
}

templates/example05.tmpl:

{{define "page"}}
<html>
<body>
{{template "body" .}}
</body>
{{end}}

{{define "body"}}
<h1>{{.Nationality}} {{.Kind}}</h1>
<ul>
{{range .Names}}{{template "name" .}}{{end}}
</ul>
{{end}}

{{define "name"}}
  <li>{{.}}</li>
{{end}}

Output:

./bin/template05 

<html>
<body>

<h1>Greek Gods</h1>
<ul>

  <li>Zeus</li>

  <li>Ares</li>

  <li>Apollo</li>

  <li>Hera</li>

  <li>Aphordite</li>

  <li>Athena</li>

</ul>

</body>


  <li>Loki</li>