1. Define a function `sprout`

that moves the
turtle forward
and back by a small amount. In CoffeeScript, the `->`

notation defines a function, and lining up the indent is important.

sprout = (size) -># define sprout: a function with one parameterfd size# move forward by that amountbk size# backward by the same amount, end the functionpen green# use greensprout 30# run sprout with size 30

2. The function `sprout`

can be used anywhere,
including inside other functions. Try this:

sprout = (size) -> fd size bk sizetree = (size) -># tree is another function with one parameterfd size# go forward by the sizelt 30# left turn by 30 degreessprout size * 0.7# draw a sprout with 70% of the sizert 60# right turn by 60 degreessprout size * 0.7# draw another sprout at 70%lt 30# left turn by 30 degreesbk size# backward by size, and end the function pen greentree30 # call tree instead of sprout

Notice how the parameter `size`

has a different meaning
inside each function call. Inside the call to `tree`

,
`size`

is 30, but inside `sprout`

,
`size`

is 30 * 0.7 = 21.

3. Use an `if`

so that a small tree is just a
sprout, and draw a couple trees.
Each time `tree`

is called,
`size`

has another value: first 9 (which triggers the
`if size < 10`

, and then 30 (which does not).

sprout = (size) -> fd size bk size tree = (size) ->if size < 10# do the following only if size is less than 10sprout size# draw a sproutreturn# finish and return out of the function fd size lt 30 sprout size * 0.7 rt 60 sprout size * 0.7 lt 30 bk size pen greentree 9# draw a little treejump 50, 0# jump 50 to the right tree 30 # draw a bigger tree

4. How can we add branches to our branches? Make a tree out of smaller trees instead of sprouts:

sprout = (size) -> fd size bk size tree = (size) -> if size < 10 # this "if" defines the important "base case" sprout size # drawing a sprout instead of a tree when size < 10 return # it prevents tree from calling itself forever fd size lt 30treesize * 0.7 # a function can call itself! rt 60treesize * 0.7 # experient by removing one of these. lt 30 bk size pen green tree 9 jump 50, 0 tree 30

When a function calls itself, it is
called **recursion**. Again, the parameter `size`

has a different meaning each time `tree`

is called.

- When
`tree`

is called for the tiny tree,`size`

is 9, and it draws a sprout. - When
`tree`

is called for the bigger tree,`size`

is 30, and it draws a trunk and calls itself. - When
`tree`

calls itself again for the big branches,`size`

is 30 * 0.7 = 21. - When
`tree`

is called yet again for the smaller branches,`size`

is 21 * 0.7 = 14.7 - At the next level
`size`

is 9.87, which is the**base case**because size < 10, and it draws a sprout.

Notice that the 14.7 size tree draws two sprouts, and the 21 size
tree draws two 14.7 size trees (making four sprouts on its branches).
How many sprouts are there in total on a 30 size tree?
The **base case** with size < 10 is important: without it,
this program would never stop.

5. Add some randomness to make the tree seem more natural.
The function `random()`

returns a different
random decimal number betwen 0 and 1 each time it is called.

sprout = (size) -> fd size bk size tree = (size) -> if size < 10 sprout size return fd size lt 30 tree size *(0.6 + 0.2 * random())# random between 0.6 and 0.8 rt 60 tree size *(0.6 + 0.2 * random())# different each time lt 30 bk size pen green tree50