Here's the basic syntax:

for i in 1...4 {
    // this block runs 4 times (i = 1, 2, 3, 4)
    pen.addLine(distance: 100)
    pen.turn(degrees: 90)
}

The 1...4 is a closed range — it includes both 1 and 4. You can use any range you like. If you don't need the loop variable i, Swift convention is to replace it with _ (underscore), which tells the reader "we're just counting, the value doesn't matter":

for _ in 1...4 {
    pen.addLine(distance: 100)
    pen.turn(degrees: 90)
}

This draws a square in just 4 lines instead of 8! Let's put loops to work on real shapes.

Why loops? Three reasons: less typing (4 lines instead of 8 for a square, and the savings grow with bigger shapes), fewer bugs (if you update the side length, you only change one number), and scalability (a 100-sided polygon is just as easy as a 4-sided one — change the count and you're done). Loops are the foundation of every non-trivial program.

Closed range vs half-open. Swift has two range operators: 1...4 is the closed range (includes both 1 and 4, so 4 values: 1, 2, 3, 4). 0..<4 is the half-open range (includes 0 but stops before 4, so 4 values: 0, 1, 2, 3). Both loop exactly 4 times — they just use different starting points. For counting iterations, either works; pick whichever reads more naturally.

The underscore says "I don't care". Writing for i in 1...4 creates a variable called i that takes on the values 1, 2, 3, 4 in turn. If you actually use i inside the loop, keep the name. But if you're just repeating the same code 4 times (like drawing a square), replace i with _. It tells anyone reading your code "this value is intentionally ignored". You'll see i used for real in Section 09 when you draw a spiral.

If you walked around the triangle. Imagine you're standing at one corner, facing along one side. You walk forward, and at each corner you need to turn to face the next side. Because the triangle closes (you end up back where you started facing the direction you started), your total turning must equal exactly 360° — one full rotation. Share that 360° equally among the 3 corners and each turn is 360° ÷ 3 = 120°. This is the exterior angle, and it's what you pass to pen.turn().

Exterior vs interior angle. The interior angle is the angle inside the corner — for an equilateral triangle it's 60°. The exterior angle is how much you rotate when you turn the corner — 120° for an equilateral triangle. They're always supplementary: interior + exterior = 180° (because together they make a straight line). Your pen turns by the exterior angle, never the interior angle. Getting this backwards is the single most common mistake when drawing polygons.

for _ in 1...3 {
    pen.addLine(distance: 150)
    pen.turn(degrees: 120)
}

Hint: after drawing each square, you'll need to move the pen (without drawing a line) to the starting corner of the next square.

move vs addLine. Both advance the pen forward by a distance, but only addLine draws a visible line — move is silent. Use addLine when you want to draw; use move when you want to reposition the pen without leaving a trace. You'll need both in any exercise where you draw multiple separate shapes in one script.

Closed shapes return the pen home. A square's 4 turns add to 4 × 90° = 360° — a full rotation. Combined with 4 equal sides, the pen ends exactly where it started, facing the direction it started. This is why you can draw a square, then move forward, then draw another square: after the first square, the pen is at the bottom-left corner again (its starting point), facing right. The move(distance: 80) then slides it past the first square to the start of the next.

Nested loops! This solution has a loop inside a loop: the outer loop runs 3 times (once per square) and the inner loop runs 4 times (once per side). Total addLine calls: 3 × 4 = 12. You'll meet nested loops formally in Section 08.

for _ in 1...3 {
    // Draw one square (inner loop = 4 sides)
    for _ in 1...4 {
        pen.addLine(distance: 80)
        pen.turn(degrees: 90)
    }
    // Reposition to the start of the next square (no line drawn)
    pen.move(distance: 80)
}

A pattern is a repeating unit. A dashed line is one example; a tile pattern on a floor is another; a musical rhythm is another. Every pattern has a unit that repeats — for the dashed line, the unit is "draw 20, skip 10". Identify the unit, wrap it in a loop, and you've generated the whole pattern. This is the essence of procedural generation.

Total length = number of units × unit length. If each unit is 20 + 10 = 30 units long and you repeat 10 times, the total line length is 10 × 30 = 300 units. This is multiplication as repeated addition, made visible on the canvas. Change either the unit length or the repetition count and the total scales linearly — a direct application of multiplication.

for _ in 1...10 {
    pen.addLine(distance: 20)   // draw dash
    pen.move(distance: 10)     // skip gap
}

The exterior angle formula. This is one of the most useful results in elementary geometry: for any regular polygon with n sides, the exterior angle at each vertex is exactly 360° ÷ n. It follows directly from the "walk around the shape" intuition from Section 02 — total turning is always 360°, shared equally across n corners. This one formula unlocks triangles (120°), squares (90°), pentagons (72°), hexagons (60°), octagons (45°), and anything else.

Variable-driven design. Putting the number of sides in a let sides variable (from Chapter II) means you can change one number and the entire shape updates. That's the payoff of using variables instead of hardcoded numbers: sides appears in two places (the loop count and the angle formula), so they stay in sync automatically.

⚠️ The integer division trap. Swift's / operator does different things depending on the types. If both sides are Int, it does integer division and throws away the remainder: 360 / 7 = 51 (not 51.428…). If at least one side is a Double, it does decimal division: 360.0 / 7 = 51.428571… ✓. For polygons where n divides 360 evenly (3, 4, 5, 6, 8, 9, 10, 12, …) the bug is invisible. But try n = 7 with integer division and your heptagon won't close — it'll drift by about half a degree per turn. Always use 360.0 / Double(n) to get an accurate angle.

let sides = 7                         // try 3, 4, 5, 6, 7, 8, 9, 10…
let angle = 360.0 / Double(sides)   // decimal division (Double)

for _ in 1...sides {
    pen.addLine(distance: 100)
    pen.turn(degrees: angle)
}

Why 720°? — the two-loop insight. A regular polygon's path winds around once (360° of turning). A {5/2} star polygon winds around twice — the path overlaps itself, completing two full loops before returning to the start. So the total turning is 2 × 360° = 720°, spread across 5 vertices: 720° ÷ 5 = 144° per turn. In general, a {n/k} star polygon turns k × 360° / n at each vertex and winds k times before closing.

The gcd rule. A {n/k} star polygon is a single closed path only when gcd(n, k) = 1 (their greatest common divisor is 1 — in other words, n and k share no common factors). For {5/2}: gcd(5, 2) = 1 ✓ — you get the classic pentagram. For {7/2} or {7/3}: gcd(7, 2) = gcd(7, 3) = 1 ✓ — you get 7-pointed stars.

But for {6/2}: gcd(6, 2) = 2 ✗ — the path closes after just 3 steps, tracing a triangle twice, not a 6-pointed star. For {8/2}: gcd(8, 2) = 2 ✗ — you get a square traced twice.

So how do you draw a Star of David? A 6-pointed star is two overlapping triangles, one pointing up and one pointing down. You can't draw it with a single {n/k} loop because gcd(6, anything) is always greater than 1 for valid k. You have to draw two separate triangles — one, then move/rotate, then the other. This is a rare case where a single loop doesn't suffice.

for _ in 1...5 {
    pen.addLine(distance: 150)
    pen.turn(degrees: 144)
}

// gcd(7, 3) = 1 ✓, so this is a valid single-loop star
// Turn angle = 3 × 360° / 7 ≈ 154.286°
for _ in 1...7 {
    pen.addLine(distance: 120)
    pen.turn(degrees: 360.0 * 3 / 7)
}

// {6/2} degenerates, so draw two overlapping triangles instead
// Triangle 1 — pointing up
for _ in 1...3 {
    pen.addLine(distance: 150)
    pen.turn(degrees: 120)
}

// Reposition for the second triangle (pointing down, rotated 180°)
pen.move(distance: 50)
pen.turn(degrees: 180)
pen.move(distance: 25)
pen.turn(degrees: 180)

// Triangle 2 — pointing down
for _ in 1...3 {
    pen.addLine(distance: 150)
    pen.turn(degrees: -120)
}

Try at least three different angles with 50+ iterations and describe what you observe. Which angle created your favourite pattern?

Rational vs irrational angle ratios. When you turn by angle A each step, the pen's total turning after n steps is n × A. The path closes (lands back where it started) only when n × A is a whole multiple of 360° — which happens only when A / 360° is a rational number. If A / 360° is irrational (like the golden angle, 137.508°, which is 360°/φ²), the path never exactly closes — it keeps adding new lines that don't overlap the old ones, eventually covering the plane with a dense pattern.

Why 91° is interesting. 91° is almost 90° (which would give a square after 4 steps). The tiny 1° offset per corner means that after 4 steps you're 4° "off" from closing. Each "loop around" drifts by 4°, so after 90 loops (360 steps) the drift has accumulated to a full 360° and the pattern appears to have rotated once. The result is a slowly-rotating square that looks like a spiral from a distance.

The golden angle and sunflowers. The golden angle ≈ 137.508° is derived from the golden ratio φ = (1 + √5) / 2 ≈ 1.618. It's the "most irrational" angle — its ratio to 360° is as far from any rational number as possible. Nature loves this property: sunflower seeds, pine cone scales, and cactus spines are placed with successive rotations of ≈ 137.5° because that spacing never repeats and gives each seed maximum room to grow. Plant biologists call this phyllotaxis, and it's the same math that powers the patterns you'll draw here.

for _ in 1...100 {
    pen.addLine(distance: 80)
    pen.turn(degrees: 137.5)
}

for _ in 1...200 {
    pen.addLine(distance: 80)
    pen.turn(degrees: 91)
}

// Two loops around (2 × 360° / 11) gives a denser 11-pointer
for _ in 1...11 {
    pen.addLine(distance: 120)
    pen.turn(degrees: 360.0 * 4 / 11)
}

Use a nested loop to draw a ring of squares: an outer loop runs 8 times, and each iteration draws one complete square (inner loop), then turns the pen by 45° to position it for the next square.

Nested loops multiply. With an outer loop of 8 iterations and an inner loop of 4 iterations, the inner body runs 8 × 4 = 32 times total. More generally, for outer count m and inner count n, the inner body runs m × n times. This multiplicative effect is why nested loops are powerful — and also why a carelessly placed nested loop can become slow: if both counts are 1000, you're suddenly running a million iterations.

"Outer ticks slow, inner ticks fast." Think of a clock: the minute hand moves slowly while the second hand moves fast. The second hand completes a full rotation for every single step of the minute hand. A nested loop works the same way — the inner loop completes all its iterations before the outer loop advances by one step. So if you trace the order of operations, you'll see: inner 1, inner 2, ..., inner N, outer tick, inner 1, inner 2, ... and so on.

8-fold rotational symmetry. Dividing 360° by 8 gives 45° — the rotation needed to evenly space 8 squares around a full circle. The resulting ring has 8-fold rotational symmetry: rotate the whole thing by 45° and it looks identical. More generally, a ring of n shapes with inter-rotation 360° / n has n-fold symmetry. Try changing the 8 to a 6 or a 12 and see how the symmetry changes.

for _ in 1...8 {
    // Inner loop: draw one square (4 sides)
    for _ in 1...4 {
        pen.addLine(distance: 60)
        pen.turn(degrees: 90)
    }
    // Rotate to the next position in the ring (360° ÷ 8)
    pen.turn(degrees: 45)
}

In the loop below, i starts at 1 and increases to 50. Use i directly as part of the line distance so each segment is longer than the last:

for i in 1...50 {
    pen.addLine(distance: /* use i here */)
    pen.turn(degrees: 91)   // try different angles!
}

Try adjusting the turn angle — small changes produce very different spirals. What angle gives the tightest coil?

Arithmetic vs geometric growth. There are two fundamentally different ways to make things grow in a loop:

• Arithmetic: add a constant each step (i * 3 → 3, 6, 9, 12, 15, …). The gap between consecutive values is constant.
• Geometric: multiply by a constant each step (3 * 2^i → 6, 12, 24, 48, 96, …). The ratio between consecutive values is constant.

Spirals where each arm is a fixed amount longer (arithmetic) are called Archimedean spirals. Spirals where each arm is a fixed ratio longer (geometric) are called logarithmic spirals — and they're what you see in nautilus shells, hurricanes, and galaxies. For this exercise, stick with arithmetic growth.

Type casting revisited. Swift won't let you multiply an Int (like i) by a Double (like 3.0) directly. You have to convert: Double(i) * 3. Same rule you saw in Section 05 with Double(sides). The type system forces you to be explicit about converting between integers and decimals — it's strict, but it prevents subtle rounding bugs.

Why does 91° make a nice square spiral? A regular square uses 90° turns. Turning by 91° each step means the pen almost traces a square but rotates by 1° every iteration. Combined with the growing line length, the result is a square that spirals outward. Change to 92° or 95° and the spiral tightens; change to exactly 90° and you get a growing-square-without-rotation.

for i in 1...50 {
    pen.addLine(distance: Double(i) * 3)
    pen.turn(degrees: 91)
}

for i in 1...200 {
    pen.addLine(distance: Double(i) * 0.5)
    pen.turn(degrees: 15)
}