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

[lmock]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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.