The Paper Machine · TraceForge

Adding two numbers

Reading skill: let + arithmetic · 3 steps

let a = 6
let b = 4
print(a + b)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`a`	`b`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

A box that changes

Reading skill: var reassignment · 4 steps

var score = 3
score = score + 5
score = score * 2
print(score)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`score`	Prints
1
2
3
4

Check it on the live machine: sparkanvil.org/play/traceforge

Filling in a sentence

Reading skill: string interpolation · 3 steps

let name = "Ada"
let age = 9
print("\(name) is \(age)")

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`name`	`age`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Sharing that does not divide evenly

Reading skill: Int division truncates · 3 steps

let total = 7
let friends = 2
print(total / friends)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`total`	`friends`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Sunny AND warm?

Reading skill: Bool and && (both must be true) · 3 steps

let sunny = true
let warm = false
print(sunny && warm)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`sunny`	`warm`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

The opposite of the door

Reading skill: Bool and ! (not) · 4 steps

let door = false
let open = !door
print(open)
print(door)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`door`	`open`	Prints
1
2
3
4

Check it on the live machine: sparkanvil.org/play/traceforge

How long is the word?

Reading skill: String .count (how many letters) · 2 steps

let word = "robot"
print(word.count)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`word`	Prints
1
2

Check it on the live machine: sparkanvil.org/play/traceforge

Cookies left over

Reading skill: remainder % (what is left over) · 3 steps

let cookies = 17
let perBag = 5
print(cookies % perBag)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`cookies`	`perBag`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Two words become one

Reading skill: joining Strings with + · 3 steps

let first = "Sun"
let second = "flower"
print(first + second)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`first`	`second`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

A swap that goes wrong

Reading skill: var reassignment, in order · 6 steps

var a = 2
var b = 5
a = b
b = a
print(a)
print(b)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`a`	`b`	Prints
1
2
3
4
5
6

Check it on the live machine: sparkanvil.org/play/traceforge

Sharing with decimals

Reading skill: Double division keeps the fraction · 3 steps

let total = 7.0
let friends = 2.0
print(total / friends)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`total`	`friends`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Making a new box from an old one

Reading skill: let: a name keeps its value · 5 steps

let x = 4
print(x)
let y = x + 1
print(y)
print(x)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`x`	`y`	Prints
1
2
3
4
5

Check it on the live machine: sparkanvil.org/play/traceforge

Which branch runs?

Reading skill: if / else · 3 steps

let n = 8
if n % 2 == 0 {
print("even")
} else {
print("odd")
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`n`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Counting with ..<

Reading skill: for-in ..< (exclusive) · 7 steps

for i in 1..<4 {
print(i)
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`i`	Prints
1
2
3
4
5
6
7

Check it on the live machine: sparkanvil.org/play/traceforge

Counting with ...

Reading skill: for-in ... (inclusive) · 9 steps

var sum = 0
for i in 1...3 {
sum = sum + i
}
print(sum)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`sum`	`i`	Prints
1
2
3
4
5
6
7
8
9

Check it on the live machine: sparkanvil.org/play/traceforge

How long, and which one?

Reading skill: arrays: .count + index · 3 steps

let pets = ["cat", "dog", "fish"]
print(pets.count)
print(pets[0])

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`pets`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Hot, mild or cold?

Reading skill: if / else if / else · 4 steps

let t = 15
if t > 20 {
print("hot")
} else if t > 10 {
print("mild")
} else {
print("cold")
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`t`	Prints
1
2
3
4

Check it on the live machine: sparkanvil.org/play/traceforge

A loop that visits each word

Reading skill: for-in over an array · 8 steps

let words = ["red", "fox", "ran"]
for w in words {
print(w.count)
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`words`	`w`	Prints
1
2
3
4
5
6
7
8

Check it on the live machine: sparkanvil.org/play/traceforge

Packing a bag

Reading skill: arrays: .append adds to the end · 5 steps

var bag: [String] = []
bag.append("pen")
bag.append("map")
print(bag.count)
print(bag[1])

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`bag`	Prints
1
2
3
4
5

Check it on the live machine: sparkanvil.org/play/traceforge

Fixing one score

Reading skill: arrays: changing one item · 3 steps

var scores = [4, 7, 2]
scores[1] = 9
print(scores)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`scores`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

How many are even?

Reading skill: counting with if inside a loop · 18 steps

var evens = 0
for n in 1...6 {
if n % 2 == 0 {
evens = evens + 1
}
}
print(evens)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`evens`	`n`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Check it on the live machine: sparkanvil.org/play/traceforge

Getting louder

Reading skill: building a String in a loop · 9 steps

var s = "go"
for i in 1...3 {
s = s + "!"
}
print(s)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`s`	`i`	Prints
1
2
3
4
5
6
7
8
9

Check it on the live machine: sparkanvil.org/play/traceforge

Can they ride?

Reading skill: Bool || (or) in a test · 4 steps

let age = 10
let withAdult = true
if age >= 12 || withAdult {
print("ride")
} else {
print("wait")
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`age`	`withAdult`	Prints
1
2
3
4

Check it on the live machine: sparkanvil.org/play/traceforge

One, few or many?

Reading skill: switch picks one case · 3 steps

let n = 2
switch n {
case 1:
print("one")
case 2, 3:
print("few")
default:
print("many")
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`n`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

Jumping down by threes

Reading skill: while counting down past zero · 11 steps

var n = 10
while n > 0 {
n = n - 3
}
print(n)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`n`	Prints
1
2
3
4
5
6
7
8
9
10
11

Check it on the live machine: sparkanvil.org/play/traceforge

Adding from zero

Reading skill: for-in ..< starting at 0 · 13 steps

var total = 0
for i in 0..<5 {
total = total + i
}
print(total)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`total`	`i`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13

Check it on the live machine: sparkanvil.org/play/traceforge

Reading a function call

Reading skill: func with return · 4 steps

func triple(x: Int) -> Int {
return x * 3
}
print(triple(x: 4) + 1)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`triple: x`	`triple returns`	Prints
1
2
3
4

Check it on the live machine: sparkanvil.org/play/traceforge

A loop inside a loop

Reading skill: nested for-in · 13 steps

for a in 1...2 {
for b in 1...2 {
print("\(a)\(b)")
}
}

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`a`	`b`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13

Check it on the live machine: sparkanvil.org/play/traceforge

Building up an answer

Reading skill: accumulate over an array · 11 steps

let nums = [3, 1, 4]
var best = nums[0]
for n in nums {
if n > best {
best = n
}
}
print(best)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`nums`	`best`	`n`	Prints
1
2
3
4
5
6
7
8
9
10
11

Check it on the live machine: sparkanvil.org/play/traceforge

Stopping at the right time

Reading skill: while + condition · 19 steps

var n = 1
var steps = 0
while n < 20 {
n = n * 2
steps = steps + 1
}
print(steps)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`n`	`steps`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Check it on the live machine: sparkanvil.org/play/traceforge

Inside out

Reading skill: two functions, one call inside another · 7 steps

func double(x: Int) -> Int {
return x * 2
}
func addOne(x: Int) -> Int {
return x + 1
}
print(addOne(x: double(x: 5)))

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`double: x`	`double returns`	`addOne: x`	`addOne returns`	Prints
1
2
3
4
5
6
7

Check it on the live machine: sparkanvil.org/play/traceforge

Two boxes called x

Reading skill: a function’s own box (the same name) · 6 steps

let x = 1
func bump(x: Int) -> Int {
return x + 10
}
print(bump(x: 5))
print(x)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`x`	`bump: x`	`bump returns`	Prints
1
2
3
4
5
6

Check it on the live machine: sparkanvil.org/play/traceforge

Countdown trays

Reading skill: recursion: a function that calls itself · 21 steps

func countdown(n: Int) {
if n == 0 {
print("Go!")
return
}
print(n)
countdown(n: n - 1)
}
countdown(n: 3)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`countdown: n`	`countdown #2: n`	`countdown #3: n`	`countdown #4: n`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Check it on the live machine: sparkanvil.org/play/traceforge

Trays that hand back

Reading skill: recursion that hands values back · 17 steps

func fact(n: Int) -> Int {
if n <= 1 {
return 1
}
return n * fact(n: n - 1)
}
print(fact(n: 4))

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`fact: n`	`fact #2: n`	`fact #3: n`	`fact #4: n`	`fact returns`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Check it on the live machine: sparkanvil.org/play/traceforge

A pattern, one letter at a time

Reading skill: if / else inside a loop · 15 steps

var line = ""
for i in 1...4 {
if i % 2 == 0 {
line = line + "x"
} else {
line = line + "o"
}
}
print(line)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`line`	`i`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Check it on the live machine: sparkanvil.org/play/traceforge

Meeting in the middle

Reading skill: while with two changing boxes · 17 steps

var a = 0
var b = 10
while a < b {
a = a + 2
b = b - 1
}
print(a)
print(b)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`a`	`b`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Check it on the live machine: sparkanvil.org/play/traceforge

Copying backwards

Reading skill: walking an array backwards · 14 steps

let nums = [1, 2, 3]
var out: [Int] = []
var i = nums.count - 1
while i >= 0 {
out.append(nums[i])
i = i - 1
}
print(out)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`nums`	`out`	`i`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Check it on the live machine: sparkanvil.org/play/traceforge

Adding squares

Reading skill: calling a function inside a loop · 18 steps

func square(n: Int) -> Int {
return n * n
}
var total = 0
for i in 1...3 {
total = total + square(n: i)
}
print(total)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`total`	`i`	`square: n`	`square returns`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Check it on the live machine: sparkanvil.org/play/traceforge

A box with a label inside

Reading skill: a struct holds named boxes · 3 steps

struct Jar {
var count: Int
}
var jar = Jar(count: 2)
jar.count = jar.count * 3
print(jar.count)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`jar`	Prints
1
2
3

Check it on the live machine: sparkanvil.org/play/traceforge

A program you didn’t write

Reading skill: reading a program you didn’t write · 25 steps

let rolls = [4, 6, 2, 6, 5]
var total = 0
var sixes = 0
for r in rolls {
total = total + r
if r == 6 {
sixes = sixes + 1
}
}
let average = total / rolls.count
if sixes >= 2 {
print("lucky")
} else {
print("plain")
}
print(average)

One row per step: a new value, a check (yes or no), or a print.

Your trace table
Step	Line	`rolls`	`total`	`sixes`	`r`	`average`	Prints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Check it on the live machine: sparkanvil.org/play/traceforge