Book edits as suggested by Shriram Krishnamurthi (#22)

Dr. Krishnamurthi is a professor of programming languages and was kind enough to read the first few chapters, and had some feedback about parts that were confusing.

* I should explain the end vs. endAbsolute part better
* Images of 2D sketches should be facing the camera so it's clear what actual shape they have (e.g. the circle looks like an oval)
* Explain why 180deg in tangentialArc sometimes means up and sometimes means down

Author: adamchalmers

kcl-book/src/images/dynamic/basic_circle.png

@@ -64,7 +64,11 @@ Our third line heads back to the start of the profile, i.e. `[0, 0]`. We do this
 
 Because this is the same point that our profile starts at, this line has looped our profile back to its start.
 
-If we stopped our program here, you could see all three lines:
+We could have also used a relative line here, and looped back to the start with `line(end = [-3, -4])`. That would achieve the same thing. But this requires manual calculation. You, the programmer, have to look at all the previous lines and figure out how where the last line starts, and then "undo" all that distance by putting a line with the negative X and Y distances (so that the line goes back to the origin). In our example, this was easy, but in real-world designs this might be very tough! And even when it's easy, using an absolute point here communicates our intent better. We're just want to draw a line that returns to the start point. We don't really care about the distance here.
+
+It doesn't really matter which one you use, although note that Zoo Design Studio will usually prefer relative lines for almost everything. Closing a sketch is the one exception where Zoo Design Studio will use an absolute line.
+
+Now, if we stopped our program here, you could see all three lines:
 
 ![Result of running program 1](images/static/triangle_open.png)
 

kcl-book/src/images/dynamic/semicircle.png

@@ -26,7 +26,20 @@ It should look like this:
 
 Let's analyze this! It looks very similar to the triangle we sketched previously, but we're using `tangentialArc`. You can see it takes a relative `end`, i.e. an X distance and Y distance to move from the current point. It draws a nice smooth arc there.
 
-We wrote this arc using `end`, i.e. an X and Y distance. But we could have defined this arc differently, using a `radius` and `angle` instead. You can replace the `tangentialArc(end = [0, height])` with `tangentialArc(angle = 180, radius = height)` instead, and it should draw the same thing. 
+We wrote this arc using `end`, i.e. an X and Y distance. But we could have defined this arc differently, using a `radius` and `angle` instead (or a `diameter` and `angle`). You can replace the `tangentialArc(end = [0, height])` with `tangentialArc(angle = 180, radius = height)` instead, and it should draw the same thing. 
+
+```kcl
+height = 4
+width = 8
+startSketchOn(XZ)
+  |> startProfile(at = [0, 0])
+  |> xLine(length = width)
+  |> tangentialArc(diameter = height, angle = 180deg)
+  |> xLine(length = -width)
+  |> tangentialArc(endAbsolute = profileStart())
+```
+
+Here, the angle `180deg` is measuring a counterclockwise angle. To make the arc go the other direction (clockwise), you'd use `-180deg`.
 
 The second `tangentialArc` call takes an absolute point. We tell it to draw an arc from the current point to the start of the profile. This should remind you of how straight lines can use either `end` (relative) or `endAbsolute`.
 
@@ -53,14 +66,14 @@ It should look like this:
 
 ![A spiral made from many tangential arcs](images/static/spiral.png)
 
-This works because each tangentialArc is drawing half a circle, away from the previous arc, and the circle is getting slightly larger each time.
+This works because each tangentialArc is drawing half a circle, away from the previous arc, and the circle is getting slightly larger each time. The `180` is a counterclockwise angle, so each time we draw a new arc, it bends around the circle counterclockwise.
 
 ## Circles
 
 And lastly, let's look at the humble circle.
 
 ```kcl=basic_circle
-startSketchOn(XY)
+startSketchOn(XZ)
   |> circle(center = [0, 0], radius = 10)
 ```
 

kcl-book/src/images/dynamic/sphere.png

@@ -151,28 +151,30 @@ You can make a sphere by revolving a semicircle its full 360 degrees. First, let
 
 ```kcl=semicircle
 radius = 10
-startSketchOn(XY)
+startSketchOn(XZ)
   |> startProfile(at = [0, 0])
   |> yLine(length = radius * 2)
   |> arc(angleStart = 90, angleEnd = 270, radius = radius)
 ```
 
 <!-- KCL: name=semicircle,skip3d=true,alt=Sketching a semicircle-->
 
-Then we can `close()` it and add a call to `revolve(axis = Y, angle = 360)` to revolve it into a sphere:
+Then we can `close()` it and add a call to `revolve(axis = Y)` to revolve it 360 degrees into a sphere:
 
 ```kcl=sphere
 radius = 10
-startSketchOn(XY)
+startSketchOn(XZ)
   |> startProfile(at = [0, 0])
   |> yLine(length = radius * 2)
   |> arc(angleStart = 90, angleEnd = 270, radius = radius)
   |> close()
-  |> revolve(axis = Y, angle = 360)
+  |> revolve(axis = Y)
 ```
 
 <!-- KCL: name=sphere,skip3d=true,alt=Revolving a semicircle makes a sphere -->
 
+Note that here, we omitted the `angle` argument from the `revolve` call because it defaults to 360 degrees.
+
 ## Lofts
 
 All previous methods -- extrudes, sweeps, revolves -- took a single 2D shape and made a single 3D solid. Lofts are a little different -- they take _multiple_ 2D shapes and join them to make a single 3D shape. A loft interpolates between various sketches, creating a volume that smoothly blends from one shape into another. Let's see an example: