10. Trees and Fractals Using Recursion (LA Review - Sp15)

lmock commented 9 years ago

Your Name:

Overview of Lab Comments: i.e. Was this lab good or bad? Too fast? Too Slow? Does it need something new?

--- For each specific Issue (Copy this section as many times as necessary) ---
- [ ] Page Link:
      Type of Issue: i.e. (code) bug, grammar, typo, lack of clarity, etc
      Severity: i.e. "prevents students from continuing", "minor inconvenience", etc
      Comments: Description of the problem, what can be done to fix it, etc.
- [ ] Page Link:
      Type of Issue: i.e. (code) bug, grammar, typo, lack of clarity, etc
      Severity: i.e. "prevents students from continuing", "minor inconvenience", etc
      Comments: Description of the problem, what can be done to fix it, etc.

Justin-Kim72 commented 9 years ago

Justin Kim

Overview of Lab comments: The lab is very nicely done slowly introducing the idea of Recursion. It has a good amount of questions, testing the students understanding of recursions. It doesn't have too many words and there's a lot of good exercises that test on recursion. I was surprised though that it didn't a general definition of Recursion and the base case/recursive case. I think defining recursion first would be nice.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/search-for-fractals-in-nature.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&noassignment&noreading&novideo Type of Issue: order of slides Severity: Minimal Comments: I think this slide should be first and then have another slide introducing recursion. That way when they start on the trees, they understand both iterative and then the recursive case.

Meghna15 commented 9 years ago

Your Name: Meghna Dasgupta

Overview of Lab Comments: I liked the pace of this lab as it introduces the students to a tough concept slowly by breaking down the problem into the simplest possible ways. I also liked the use of tables to compare the different tree blocks as this made the repetition more obvious.

[ ] Page Link:http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/vary-your-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Repetition Severity: Minor Comments: I don't think this page is required after the multiple choice questions on the previous page as it covers the same concept.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Difficulty Level Severity:Moderate Comments: When I did this lab as a CS 10 student, I found the C-Curve extremely difficult and did not understand it till my TA explained it to me. I think the TAs should either go through this problem in lab or more hints should be provided for the C-curve in the lab itself.

nzoghb commented 9 years ago

Your Name: Nicolas Zoghb

Overview: I remember learning about recursion during this lab and disliking it greatly. Taking CS61a and looking over the lab, it hasn't gotten any easier to understand. While fractals seem like a great introductory subject to recursion, they don't teach students about the power of recursion and what can achieve. If fractals are used to teach recursion, they should be taught with the utmost attention to detail and explained very thoroughly.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/recursive-tree-part-1.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: lack of explanation Severity: potentially harmful Comments: This page poses the question "How can we use a tree block inside a tree block? It doesn't exist yet!" which is something that would undoubtedly be on every student's mind. The problem is that the question isn't actually answered at all throughout the lab, it simply expects the student to draw conclusions from snippets of code and screencaps of the results.
[x] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: missing space Severity: very minor Comments: near the bottom of the page, there's a space missing between '3.' and 'See'.
[x] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Isse: lack of information Severity: major Comments: this page would have been much more useful early on in the lab. A walkthrough of what goes on in a recursive script is exactly what is needed. Unfortunately even this page falls short as the importance of the base case is never fully explained and neither is what actually happens when a block is called recursively. i.e. a simple line like "the block runs again within it's parents block with a new set of parameters. If it encounters another recursive block, that block will run again with the first child block, etc. until it reaches the base case."

anushasyed commented 9 years ago

Anusha Syed

Overview: Although this lab is really great, I think these exercises might not be the best introduction to recursion. Based on personal experience, I didn't understand recursion at all until we learned about recursive reporters since I felt it was clearer how problems can be broken down with those. But overall, I think the exercises in this lab are really helpful to see what recursion can be used for and how it can really make some problems easier.

Page link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of issue: lack of explanation Severity: major Comments: I think the jump to building each level block to using recursion is a bit confusing since it's never explained how reducing the levels calls the function again until it reaches the base case (which isn't clearly defined until later). If each step of the recursive part of the function was explained in detail, I think this exercise and recursion in general would be a lot clearer.

Page link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of issue: unnecessary exercise Severity: minor Comments: Since this lab has lots of new information, I think the exercise to make your tree realistic should be placed at the end or something so the students can just focus on understanding how to use recursion to make trees first.

rwason commented 9 years ago

Name: Rishabh Wason

Overview: I think that this lab is actually lab 10 and not lab 9 as it is labeled on the github website. Other than that I think that this lab does a very well and detailed job of explaining and introducing recursion. It has a variety of practice questions and helps the student understand what recursion truly is about. I think that the idea of recursion may be slightly confusing at first for a lot of students but as they progress through the lab, they should have a better idea of what they will be dealing with.

[x] Page link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/selftest1.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Severity: Minor Comments: When you hover over the image on the first question of this page, it says that “There should be an image here” when there is already an image there.
[ ] Page link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/vary-your-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Severity: Minor Comments: I think it is good that we tell the student the basic steps here. I think that it would be more effective if we show them the relationship between this explicit example and the implicit structure of a recursive function(base case, recursive case, and recursive call). Explicitly linking this example to the definition of a recursive function will help the student understand the idea of recursion better.

sayabe commented 9 years ago

Your Name: Satoko Ayabe

Overview of Lab Comments: I think that this lab itself was well-paced and slow enough for the students to be able to understand tree recursion. However, I think that having tree recursion and concurrency right after each other will be intimidating for students. It might've been better if we had concurrency, the finch robot lab, and then tree recursion.

--- For each specific Issue (Copy this section as many times as necessary) ---

[x] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: i.e. lack of clarity Severity: i.e. minor inconvenience Comments: in this page we just wrote out "what is the base case here?" but then I'm not sure if students remember/fully understand what is meant by base case (even if it was mentioned before in lecture). It might be helpful to add ("Hint: the simplest possible solution to the question/the simplest tree possible!")
[x] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: i.e. lack of clarity Severity: i.e. minor inconvenience Comments: I remember getting stuck on this debugging questionwhen I took the course last semester. It might be helpful to put something like "hint: you may want to create new variables!"

amy97 commented 9 years ago

Your Name: Amy Vatcha

Overview of Lab Comments:

The introduction to recursion on the first page of the lab is very informative as it gives clear step-by-step instructions to approach recursion and is specific enough to prevent students from making common mistakes.
Showing the recursive and non-recursive solutions to drawing the tree is helpful as students can see which chunks of code have been eliminated through recursion.
The link to fractals in nature is a great ending to the lab since it introduces the practical application of recursion. Overall, this was a great lab that was fairly paced and introduced concepts in a logical sequence.

xmhjch commented 9 years ago

Your Name: Jiachen Hu

Overview of Lab Comments: This lab started smoothly and gently slide into recursion. The practice problems are quite reasonable and the tree explanations, especially using tree1, tree2 to eventually get to recursion, are very intuitive. However the content, especially after and including the random tree part, is still bit challenging.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Severity: minor Comments: Question three can probably be rearranged after "What was changed part". Some Students may be spending time on figuring our how to draw the natural tree without knowing that there are hints behind.
[ ] Page Link:http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Severity: minor Comments: I used script variables to solve this problem. I am not quite sure whether this is the encouraged method.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Severity: minor Comments: It would be still a little hard to understand the nature of this recursion since the difficulty of observing the pattern of the recursion increased. It would be really helpful if there is gif or animation to show the actual trail of the sprite. (That however would probably make this problem too much easier...)

tcabs17 commented 9 years ago

Tori Cabot

This lab does a fantastic job of incorporating pictures and explanations. Recursion is a tough concept to grasp at first and this lab is clear and not overwhelming in scale. The self-quizzes are particularly helpful and applicable.The c-shape problem is hard and is going to hang some people up but with some assistance in lab it is totally doable. In order to answer the question posed on the first page, we should provide a recap explanation of recursion at the end of the lab emphasizing how we can use a block inside itself.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/snowflake.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: difficulty Severity: minor Comments: In the snowflake part of the lab, perhaps we could try to get students to also figure out the amount of degrees to turn. If we are giving them basically all of the base case and the sequence of recursive calls, we could probably show them a picture with angle measurements on it and get students to apply those angle values in the appropriate turn blocks.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: unnecessary
Severity: minor Comments: The first line of the lab says we are going to show students how to draw the first depiction of a tree. Although this is a cool application of recursion, figuring out how to make the tree look pretty isn't the most important part of the lab. Perhaps there should be an extra option to try to make the fancy-looking tree if students have time.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: clarity Severity: minor Comments: This page is necessary and serves an important function. However, the breakdown would be more visually appealing and easier to comprehend if it was drawn, with arrows pointing to what each part of the block does. It might also be advantageous to include an explicit explanation of why we are multiplying size by .75 and subtracting 1 from levels.

meghnac commented 9 years ago

Name: Meghna Chatterjee

I felt this lab was very thorough in the beginning in getting its users to understand visually and conceptually what recursion. However, I feel some more information about fractals (more thorough examples/guidelines/steps, etc.) may be necessary. The concept of recursion is clear from the lab, but it is a little difficult to tie it into fractals to figure out what exactly the base case of the fractal is and what steps are repeated to create the image. The images are somewhat helpful for the C-Curve but some more explanation may be needed to really get students to understand what is going on. I feel in the future an entire lab on fractals might be more useful so that students really understand how to tackle fractal problems (as this will be needed for exams).

[ ] Page Link: http://beautyjoy.github.io/bjc-r/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of issue: Clarity Severity: Moderate (may affect understanding) Comments: Some more fractal examples might be useful before jumping into this one, perhaps some base code (as was provided for the snowflake example). A little difficult to follow what's happening with the images starting from the 3rd one. Maybe a slow gif of the turtle making the image to get an understanding of what's happening.

eurieoh commented 9 years ago

Eurie Oh

I thought that this lab was in general pretty clear. However, I don't think it really explained how using the block within the block works clearly. Also I think when using images for the C-curve, it would be better for them to be oriented the same way they would in Snap!.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Issue: clarity Severity: Moderate Comments: In the explanation of the images, it says that the sprite should be pointing right, but the images don't necessarily correspond with that. For example, in the second image, if the sprite is to be pointing right initially, then the red line should be horizontal and the blue line should be vertical, not at angles, while the sprite should be point to the right. When I took this class, I was pretty confused because of those pictures, so maybe it might help if they were to be adjusted.

frankyguerrero commented 9 years ago

Your Name: Rocio Guerrero

Overview of Lab Comments: Definitely a challenging lab, but well-written and a good way of teaching tree recursion. I like how the lab slowly builds up from drawing one tree to combining several trees to show the concept of a base case and a recursive case. The multiple choice areas were also very helpful in drilling the tree recursion concept and making sure the student fully understands each step of recursion and the different effects in changing up a few parts in his/her code before moving on to the next sections of the lab. It was also helpful that the lab had screenshots of code to help the student visualize how recursion looks like generally.

cynthiaha commented 9 years ago

Your Name: Cynthia

Overview of Lab Comments:

-The first few pages on tree recursion are very clear in explaining how hard coding can be converted to recursion. It allows students to easily see which blocks of code can be eliminated when using recursion -I liked the self-test pages because it breaks the lab into smaller sections and allows students to think about what they have learnt so far and make sure they understand what they have been introduced to so far -Overall I think the lab had a great pace and was able to introduce the visual aspect of recursion

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Difficulty Level Severity:Minor Comments: This problem may be quite challenging for students to see how the recursive parts progress. It may be helpful to include gif to see how the sprite moves, or at least include the ending location and orientation of the sprite after each case.

mikomwang commented 9 years ago

Your Name: Michael Wang

Overview of Lab Comments: Though I think this is a notoriously tough lab, it breaks down recursion into digestible parts. One VERY IMPORTANT idea that I think should be ingrained into a student's mind from even the first level tree fractal example is that the sprite must point in one direction while beginning, but also end in the same position AND point in the same direction it started out with. Personally, that was one of the reasons why tree fractals using recursion were so confusing for me, and hopefully that will give clarity to many students facing the same problem as well. Additionally, though it is mentioned, I think there should be a separate page (Maybe even with flashing letters and big font just for emphasis, lol) that just reminds the student to go from the base case to your first level, and let everything else be taken on by a recursive leap of faith.

lizapraprotnik commented 9 years ago

I think this lab is a great introduction to recursion. It's good that it emphasizes that a recursive function needs a base case and a recursive call. I also like how it introduces the concept visually through the tree drawing. However, I would introduce the idea of a base case and a recursive call at the very beginning of the lab because I think it can get confusing if it's unclear what drawing the trees is actually leading to.

Page link: Type of issue: explanation http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html I would put the bottom part of this page, which explains what a base case and a recursive case are, at the very beginning of the lab. I'd also define what exactly recursion is at the beginning of the lab, rather than the middle. This would help the students understand what the purpose of the tree drawing is.

mfujimoto commented 9 years ago

Your Name: Mason Fujimoto

Overview of Lab Comments: Overall I think it is very good lab for visualizing recursion (important conceptually when doing non-visual operations such as the Fibonacci sequence). Going through the exercises of the lab I have two major concerns: 1)The amount of time to do this lab may exceed two hours. I think we should aim not do that. Perhaps we could have students choose which of the last two exercises (snowflake or c-curve) they would like to do and eliminate some unnecessary features of the lab (coloring the tree). 2) The concept of the sprite "ending up" where it started is talked about when examining the first tree code. However this is not what we end up doing when creating the c-curve and snowflake (there is net movement of the sprite from start to finish as we have described the problem). I think we should change the parameters of the last two problems or add an explanation for this difference.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/snowflake.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: consistancy Severity: confusing, but not broken Comments: The base case of the snowflake is described as drawing a single line starting at one end and ending at the other. This is different from the previous page analyzing the components of the tree stating clearly that the sprite ends up where it started. This problem could be fixed by stating this is a necessity for creating a connected tree and not a requirement for recursion.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: relevance Severity: minor Comments: This lab could be slimmed down in terms of time by not requiring the tree to be colored. I do like how this foreshadows the concept of leaves in CS61A, but I feel it is not necessarily brought up again and can be excluded. If it remains included, an explanation might be in order to elucidate the significance of distinguishing the smallest case.

18epedersen commented 9 years ago

Your Name: Emily Pedersen

Overview of Lab Comments: I really enjoyed this lab. It is so powerful and cool that a student can visually create something beautiful and understand it is an example of recursion! I like how the lab takes you step by step into how to make a tree fractal of level 2, and then shows you the more general equation to make a tree fractal. I also thought that the page for the snowflake recursion was very clear- it makes a hard problem doable.

[x] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: lack of clarity Severity: minor inconvenience Comments: To introduce the problem that comes about when your code doesn't have a base case, we should maybe remind the students that in recursion you need a base case and a recursive case. Because when I was going through it, this really confused me because I at first thought that the level 1 tree was our base case and that would be taken care of by the level-1 block.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: lack of clarity Severity: minor inconvenience Comments: I found the description of where the sprite should be facing a bit confusing. I know when I was doing this lab as a student, I was confused about where the sprite should face and this is very important to get this code working.

carolinekim commented 9 years ago

Your Name: Caroline Kim

Overview of Lab Comments: The lab explains how recursion works and students are able to understand recursion visually by creating a fractal tree. While reading through the lab, I felt that it would be helpful if there was a chart or a recursion tree that clearly demonstrates how recursion works (for example, drawing a recursion tree of drawing a fractal tree of level 3 with: "Tree of level 3" --> "Tree of level 2" --> "Tree of level 1 (BASE CASE)" to clearly show what calling the function within itself leads to- which will also give students a better idea of what the base case is and should be). Overall, the lab is not too complicated (but a little time consuming).

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Difficult question Severity: Minor inconvenience Comments: For the "crazy tree" bug fixing assignment that the students need to do, possibly adding more hints or attaching a solution (or explaining the solution) on the next page of the lab would be helpful.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Image positioning Severity: Minor inconvenience Comments: Students will have an easier time reading the description of the breakdown of the code into the base case and the recursive case if the image was placed next to the word explanation. Since the image of the code is placed under the description, students need to continuously scroll up and down to match the description with the actual code.

ArielleSpencer commented 9 years ago

Name: Arielle Spencer

Overview: Overall, great lab and one of my favorites (except for c-curve!). Does a god job introducing fractals with a small amount of recursion without overwhelming. Only thing would be that the slide that details the recursive process is just a giant page of plain text and not super engaging. Maybe adding some more color/examples/pictures throughout the text would help.

Specific: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/recursive-tree-part-2.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Severity: very minor Students might get caught on the fact that their generalized tree block wouldn't work without going on to the next page that solves the problem.

page: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html severity: very minor The ideas of having a base and recursive case are barely thrown in at the bottom of the page, I almost missed them, but they're super important ideas. Maybe make more obvious (even though it is detailed on the next page).

page: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html severity: moderate The C-curve (and less-so the snowflake) are really really difficult, maybe specify that they're extra practice but not required

Laralinmcc commented 9 years ago

Lara McConnaughey

Overview of Lab Comments: i.e. The lab does a good job of easing the idea of recursion on to students. Recursion is a great way to implement abstraction and I think that should be mentioned somewhere in the lab. Perhaps where they give examples of multiple code. This lab also does a good job of telling students to read the code and see what the code is doing. Also a nice graphic of a tree being drawn that shows how a recursive tree is made up of smaller recursive trees would be nice.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: i.e. Lack of clarity Severity: i.e." minor inconvenience" Comments: At the end of the page the word recursion is mentioned with base case in parenthesis. I think because this lab is all about recursion maybe the definition of recursion could be moved to the next page and be bolded or have some sort of format that says to the students hey this is important and this is what recursion is.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: i.e. lack of clarity Severity: i.e. "prevents students from continuing" Comments: In the second bullet point the pronoun This is used ,but it is confusing to what This is. maybe instead of writing "this" it could be something more along the lines of "the problem we are dealing with" Also there should be more of a stress that an If-Else block is used in the body of a recursive script

jesseearlin commented 9 years ago

Name: Jesse Moore

Overall of Lab Comments: I think this lab does very well in introducing the concept of recursion visually, especially the need for a base case in recursive code. The pacing was slow, as is needed for such a complicated and critical concept, and the quiz questions were useful in helping to understand the many complexities of coding recursively. My only problem is that, since this is a very visual lab, there should be as many visual aids as possible and not just huge chunks of text with no context.

Page Link:http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: page format Severity: minor inconvenience Comments: The c-curve page is somewhat difficult to understand because it begins with a lot of text and leads a lot of scrolling down to see all the phases of the c-curve. Perhaps the pictures of the curve can be formatted in more of a grid configuration as opposed to one on top of the other, forcing the student to scroll back and forth between reference images and description.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: lack of clarity Severity: prevents students from continuing Comments: The crazy-tree problem is a bit confusing, especially with the cryptic hint of creating a variable. The hint should be elaborated on a bit more because variable assignment in recursive code can easily go wrong and frustrate the student.

Omarb62 commented 9 years ago

Your Name: Omar Buenrostro

Overview of Lab Comments: When I was in CS10, I remember absolutely hating the fractal lab because it was one of my first encounter's with recurision. As I read it over today, I realized that the problem was not the lab itself in terms of difficulty, but rather that I had not developed a way of understanding these problems. This is one of the labs that you have to sit down and slowly try to understand what is going on at every step of the problem. If one tries to rush through the lab just to get it over with, it will only create more difficulties for them in the future. Needless to say, I really liked the amount of quizzes in this lab precisely because it forces a student to slow down and digest the material. And besides a few topics that could be more emphasized (i.e. number of recursive calls, keeping track of where the sprite starts and ends, ect.), this lab does an excellent job as a visual introduction to recursion.

parsaattari commented 9 years ago

Parsa Attari Lab preview and comments: I remember doing this lab last semester and really disliking it. It wasn't until I took 61a that I fully understood recursion and fractals, even though I still sometimes struggle. I feel like this lab is really important for understanding recursion and we should slowly walk the students through the steps. There were somethings that were different on this lab than the one from last semester and one of them was the amount of questions asked during the lab. I personally feel like the questions are really helpful, especially if there is a clear explanation of why the answer is right. I believe there is more room for questions and the explanation of the answers should be more clear.

migugalde commented 9 years ago

Miguel Ugalde Lab preview and comments: I think that this lab is nicely paced, visual way of learning recursion. However, after taking cs61a, I feel like this lab does not focus on the types of recursion used in that class. If the lab/ class could integrate data abstraction, I think understanding recursive trees would be easier. It would take longer to learn but I think it would be more thorough. I think the lab lacks an aspect of tree analysis, like being able to get data out of the tree and being able to manipulate.
I think the pictures and diagrams are helpful for learning the nature of recursive functions, but not really for what kind of data can be harvested from them.

ilinabg commented 9 years ago

Your Name: Ilina Bhaya-Grossman

Overview of Lab Comments: i.e. I think that this is a fun lab but I found it kind of strange that there was no short introduction to recursion, even if they have gone over it in class? I appreciated the really thorough explanation of the recursive tree solution (the step by step bullet point explanation). I also think that the comprehensive self tests (the two pages) help with a full understanding, just because recursion can be such a tricky concept. However, I think that the lab could be a little clearer with the C-curve, I remember being very confused by that slide the first time I saw it. Overall I feel like this is a well written lab that uses diagrams and imaging to explain recursion in a pictorial way (rather than just words which might be more confusing), maybe a possibly addition would be the introduction.

Hungukaroo commented 9 years ago

Elizabeth Steger

Overview: This has always been one of my favorite labs. It beautifully intertwines the easy graphics of Snap! and a seemingly simply recursive projects. The quizzes perfectly cover the modifications they can make to change their tree in a way that I think helps students better understand what part of their code translates into different fractal forms. I also enjoy the look at fractals in nature at the end of the lab; it's a nice treat that could be distracting if earlier in the lab.

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/recursive-tree-part-2.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html

Type of Issue: Inconvenience Severity: Minor Comments: Step 6 invites the students to make a tree-4 block if they "can stand it," and I know the purpose is to show them how tedious things are if they don't generalize, however I think that just building tree-3 shows them this. I know there are students who may not move on until they have done this, and it's a deliberately tedious exercise that I think isn't necessary.

morganewing commented 9 years ago

Your Name: Morgan Ewing

Overview of Lab Comments: I like how this lab explains recursion by beginning with creating blocks of different tree levels and eventually introducing the base case and the recursive case. Though it’s a lengthy process, I think this helps students understand the idea of recursion. I also like that the “Base Case and Recursive Case” page explains exactly how the code works. However, I think that the Snowflake and the C-Curve are the most difficult activities and should have more explanation about how to go about coding them.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: unnecessary/time consuming activity Severity: minor Comments: When I did this lab, I spent a very long time trying to create a realistic tree and I did not have much time for the more difficult activities toward the end of the lab. I think there should at least be a note telling students not to spend too much time on the problem because the rest of the lab is probably more important.

knmcgauley commented 9 years ago

Katherine McGauley

Overview of Lab Comments: i.e. Was this lab good or bad? Too fast? Too Slow? Does it need something new?

--- For each specific Issue (Copy this section as many times as necessary) ---

[x] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html

Comments: I really like the step-by-step walk through of the tree example in the first 3 pages of this lab. I think the screenshots of both the code and the pictures being drawn are particularly helpful to illustrate just what is going on.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html

Type of Issue: Lack of Clarity

Severity: A bit confusing Comments: In the text box describing the general approach to a recursive problem, the second bullet point (beginning with "If this isn't the base case...") is ambiguous--I didn't immediately understand what "this" referred to, or that this bullet point meant to describe the recursive step. I would recommend rewording to something like "If we are not done, that is, if our conditions do not satisfy the base case, then we think to ourselves...". I think a lead-in would make it more clear what part of the problem is being referred to.

thomaslee4 commented 9 years ago

Your Name: Thomas Lee

Overview of Lab Comments: I think that this lab was a good introduction to recursion, and I thought that the lab was effective in its ability to test students on recursion without making them code recursively, which can be scary when first starting. I especially liked the part of the lab where students have to identify what was changed in the code to produce a specif tree. I also like how the lab incorporated an variety of problems including problems where the sprite must return to the start position, as well as problems where the sprite should end in a different place.

soham14 commented 9 years ago

Your Name: Soham Kudtarkar

Overview of Lab Comments: i.e. Overall, this was a very effective lab—it does its job well in terms of teaching what recursion is. I recall that this lab helped me very much when I took CS 10 and feel that it is one of the most important labs in this course. The lab is very intuitive and the average student could probably get through it without much assistance. My only worry about this lab is the final fractal problem, which may prove to be difficult to students who are just learning about recursion. Other than that, this lab is very well put together.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Lack of clarity Severity: minor inconvenience Comments: I don’t think that the base case is demonstrated thoroughly enough here. I feel that it would be a better idea to have the student discover for herself the structure of a base case, i.e. guiding her through the logic of the base case and then suggesting a conditional that stops the recursion at a point. I believe it is also a minor inconvenience that the words “base case” are only mentioned at the very bottom of the page. For a page that is dedicated to the base case, I feel that its name should appear earlier in the page.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: lack of clarity Severity: minor inconvenience Comments: The problem that is posed to students is to make a complex fractal with the knowledge that they gained from the lab. I feel that this problem might be a bit too complex for students who had no idea what a base case was thirty minutes earlier. I feel that this problem would be more effective if it were made more intuitive or had more guidance.

jessej-luo commented 9 years ago

Your Name: Jesse Luo

Overview of Lab Comments: i.e. I remember this lab being relatively difficult because of the recursive concepts. I think in general, it makes a few conceptual jumps that are a bit difficult to understand. I remember that the one tip that really helped me was really understanding that there's only two cases you need to take care of when drawing the fractal, the base case and recursive case (meaning diagram 0 and diagram 1). Then assuming that it would work from there. It's good because now, there's a page that really goes through that although I feel that it could start from something more simple and build up towards that.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html

I think there could be a bit more explanation as to the point of drawing the crazy tree and breaking it down a little more. I personally think that recursion is a very difficult concept and that there should be more time spent on figuring out the concepts rather than just doing examples because it could be a bit brute force when doing recursion. I think there should also be more emphasis on the idea of "leap of faith" which is really important.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html

For me at least, I felt the colors were more confusing than anything. Other than that I think its pretty good. The most important thing I feel is spending more time explaining the concept of recursion and guiding the students more since recursion is very difficult and a huge conceptual jump from loops and such.

jesslarson commented 9 years ago

Your Name: Jessica Larson

Overview of Lab Comments: This was by far my favorite lab! I love the creativity students can have with this!

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link:http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: lack of clarity Severity: minor inconvenience Comments: This was a little difficult to understand what exactly the crazy tree was supposed to be.

juliaalcaraz commented 9 years ago

Your Name: Julia Alcaraz

Overview of Lab Comments: I really liked this lab, it effectively introduced recursion using trees. It also explains recursion pretty clearly. The additions that were made this semester are very helpful. Also, I thought the quizzes ensured the student's understanding of the material.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/random-tree.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: lack of clarity Severity: minor inconvenience Comments: I thought the hint for the crazy tree was not very helpful, instead maybe it could urge the students to notice the pick random blocks, and think about the problem those blocks might pose in the code provided.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: information displaced Severity: minor inconvenience Comments: The very last explanation for the c-curve suggests to the student to create a block called flake1 and flake2, the way they were told to do with the trees previously. I think this information should be place in the previous page so that the students can see it when they are attempting to fill in the snow flake, although it might also be helpful to include on this page with the suggested block names changed to ccurve1 and ccurve2.

JiazhenChen commented 9 years ago

Your Name: Jiazhen Chen

Overview of Lab Comments: I like this lab very much. It's well paced nicely illustrated. It gives a both visual and written explanation for recursion. Especially the visual part, it gives the students a direct understanding of this tough concept. I also like the visual examples in the lab. They are all really pretty and interesting. This helps to arouse the students' interest and their artistic talent a lot.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: inconvenience Severity: minor Comments: For the last part that ask to draw a natural tree. People may get stuck here since it's a bit difficult. The Lab check off questions don't require to check this block. Maybe the slide can add a sentence like "If you get stuck here, feel free to move on and come back later." or some similar sentences.

william0cheung commented 9 years ago

William Cheung

Overview: This is one of the most important labs, since it introduces recursion. I really like the idea of drawing the trees as intuition. With a visual to guide learning recursion, I believe students will appreciate and learn in a better way. Maybe stress the base case and recursive case a bit more, but other than that this lab is fantastic. There is a good in-lab quiz for understanding tree inputs.

Issues: Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type: inconvenience Severity: minor Comments: Maybe need a visual when they reach this section. Also one of the bullet points is extremely important, (the Recursive Case one) which may be glossed over.

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/snowflake.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html type: difficult concept severity: minor Comments: The snowflake is actually pretty difficult if not given the base case or how to draw the original line; it is hard to tell how recursion is used, but if the students get it, then it's fine. Just a warning this is a usual place where students get stuck.

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html type: difficulty severity: minor/moderate Comments: the C curve is also very difficult to grasp, but this is the end of the lab; hopefully the students can still get checked off if they reach this point.

JaysanM commented 9 years ago

Jaysan Maolinbay

Overview of Lab Comments: I remember when I went through this lab last semester, this lab (the idea of recursion as a whole) made no sense to me. Now, going back through it a second time with 61A experience, everything is much more lucid; and yes, the idea of recursion is very powerful. However, the big idea of recursion may not very easy to spot in this lab. With that being said, I can imagine how some students may struggle with this lab much like I did. A recommendation I would like to make is to make more "lower-level" examples so students can build up to larger ideas/drawings in recursion. So basically just have some more optional example at-hand in the beginning of the lab. But for the majority of my peers and classmates that went through the lab last semester with me said they enjoyed the lab. So I suppose my input would only be useful for a certain population of students.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/c-curve.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: i.e. Difficulty Severity: Minor-None Comments: With the amount of knowledge learned beforehand, it may be difficult for students to solve the C-curve. I recommended more examples beforehand to help build comfort and and an overall understanding of recursion.

michen-ml commented 9 years ago

Michelle Chen

Overview of Lab comments: Overall the lab is really effective in introducing the idea of recursion. I really liked the addition of the base case and recursive case step by step guide, because it allows students to fully understand the concept of base and recursive cases ( I know I had trouble with that when I took this lab). I also think the lab questions were really helpful in visualizing how tree recursion can be applied to create a variety of shapes. However, I think the jump from trees to snowflakes and C-curves may be a little daunting. Instead adding smaller exercises in between may allow students to be more comfortable with recursion before taking on the C-Curve. Overall great lab.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/snowflake.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: difficulty Severity: minor Comments: This starts bringing up base cases where the sprite does not return to its original position, whch is very different from the beginning where we stressed the importance of returning to the original position. This may be confusing for some students. Again, recommend more practice beforehand
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue:clarity Severity:minor Comments: second bullet point is a little confusing. Delegate what to whom? Not sure what this part was supposed to be about.

Rshahatit commented 9 years ago

Your Name: Rami Shahatit

Overview of Lab Comments: I think this lab does a good job in walking the students through what exactly it is that they are going to do within this lab. I like the different parts i think that is the most useful part. seeing what exactly you are trying to cut out of your code when you use recursion. I also like the creativity that students can have with this even though some students may not want to take the time. I think that maybe it would be useful to require students to get creative with this lab as to help them understand the possibilities that they can occur with this type of recursion. it will help them see the "beauty in computing."

siyingwang commented 9 years ago

Your Name: Siying Wang

Overview of Lab Comments: Here comes to the part I really like, Draw crazy trees! This lab is good introduction to recursion. The example are great and the drawings are very interesting.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/base-cases.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue:lack of clarity Severity: i.e. inconvenience Comments: It's better to mention that the angle of the root of the tree is twice of the angle between the leaves. Otherwise, it will be hard for students to figure out the correct form.

KamikazeTomato commented 9 years ago

Your Name: Henry Chung

Overview of Lab Comments: This lab was quite a fine introduction to recursion that suffers from a couple of major roadblocks due to clarity. This applies mostly towards students who have yet to get their heads around the concept of recursion (which is admittedly a doozy), but I feel that a step-by-step illustration (perhaps with a graphic) that worked through 3 separate levels of a recursive tree would be a great source of clarification.

--- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/recursive-tree-part-2.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Lack of Clarity Severity: Minor Roadblock Comments: Students get confused as to the difference between “tree2” and the final “tree” example. It needs to be made more clear that “tree2” uses the “tree1” block while the final “tree” block uses itself in its definition. I saw multiple students not catch this distinction and see the two block as identical, halting their progress for quite some time.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/tree/treepart3.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Lack of Clarity Severity: Prevents Students from Continuing. Comments: This infinite recursion example serves as yet another significant roadblock for many students. It seems that at this point they still find it very difficult to comprehend the concept of recursion. I found the most useful way to explain it was to conceptualize each recursive call as opening another “frame” that had to be evaluated before going back to the rest of the function. It usually required me drawing out an additional frame indented out with each additional recursive call until finally reaching a base case and backtracking to the other non recursive call parts of the function. This kind of graphic aid would do wonders towards helping students get the concept before getting the validation and feedback from the tree examples.

benlsmith commented 9 years ago

Your Name: Benjamin Smith

Overview of lab comments: This was one of my favorite labs in the class. It was a great way to get introduced into recursion and really prepared me well for learning recursion in other classes. The interactive way that the tee is taught, along with the quizzes provide a great base for how to do recursion in other examples. the way that the ideas of base case and reinputing the function into itself recursively was done in a great, informative way.

KimiaG commented 9 years ago

Kimia Ghodoosian

Overview of Lab Comments: I really loved this lab when I took this class. It's great for all of the visual learners as an introduction to recursion. As more of a general commentary, is it really necessary to count the number of attempts that a student needs for a self-test question. Is it to help students measure whether they really grasp the concepts? For me, I remember that it just made me anxious to see the counter in the corner.

[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/recur/fractals/snowflake.html?topic=berkeley_bjc%2Frecur%2Frecursion-trees-fractals.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: No issue–just some thoughts Severity: minor Comments: Basically, you have the successive diagrams of the Koch snowflake showing the n = 1, n = 2 etc. It might be helpful to write that underneath each image so that when students get to the in-lab midterm, the fractal format looks like something that they've worked with before.

cs10 / bjc-r

10. Trees and Fractals Using Recursion (LA Review - Sp15) #521