Lab 7: Algorithmic Complexity

[lmock]

Please comment below to leave us your lab reviews! Remember, please follow this format:

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: (you should 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.

[Frankgoji]

Franklin Lee

Overview of Lab Comments: I only noticed this now (I don't know if this was in earlier labs) but I like the fact that Alonzo tracks your progress throughout the lab in the bottom bar. There are some more pages that are exclusively blocks of text than in labs. I know that it's important to explain the material thoroughly, especially a topic like algorithmic complexity, but at the same time I'm almost certain that students will only skim the reading, or skip it entirely, just because it's a whole bunch of text. The lab doesn't seem too long, but I think that some of the more confusing aspects of the lab, like the Gauss blocks (mentioned below) may trip up some students and cause them to take longer. Also, I think that it would be useful for students to have a review of all the different algorithmic runtimes at the very end.

For specific issues:

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/time-is-of-the-es-sense.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=2 Type of Issue: Weird picture format. Severity: slightly confusing Comments: There is a picture of the stage meant to show the timer ticking in the corner, but since there's no box, only the pointer in the middle of a white, blank space, there's an odd break between the paragraphs. First looking at the page, one might not even know that we're supposed to be looking at the timer.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quiz-searching-through-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type of Issue: Lack of Clarity Severity: Moderate severity Comments: The quiz mentions "worst-case" runtime for a particular problem (walking through a list). However, this term was not explicitly defined yet in the preceding pages, and is instead defined three pages later. While it may seem obvious what a worst-case runtime would mean in this particular situation, I still think it's worth mentioning that when one describes algorithmic complexity, we generally talk about the worst case scenario, and what that means.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=8 Type of Issue: Code Bug Severity: Major inconvenience and confusion for students Comments: The lab shows two REPORTERS, which take in a list. In the Snap file, however, the students are given two COMMAND blocks, which don't have any input at all. They're supposed to use the global NUMBERS list, but if they don't pay enough attention to the code, they might not even notice that that's there!

[thorsoch]

Charles thorson

Overview of Lab Comments: Lab is pretty easy and quick if you do not have to wait for extremely time-consuming implementation tests. I think that we should condense the tests so the student is not sitting and waiting for a timing exercise to end. The 1000 number case is not worth the student's time. Also, I felt that some practice problems to distinguish between runtimes would be a good addition.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&course=&step=11 Type of Issue: time-consuming Severity: mild Comments: The lab suggesting that the students should do trials with inserting 1000 numbers into the list is probably not worth the time. Especially since some students may try to do multiple trials with code. The lab should probably not suggest doing 1000, include a pre-made 1000 list, or advise the students to save the 1000 list into a variable to prevent having to make a new one each trial. Up to 100 is enough to see the runtime. Also, I felt it would be better if there was some method of making sure that the summing implementation for non-gauss is coming up with the right answer. This would prevent a student form reaching an incorrect runtime, because their code is incorrect to begin with. Perhaps, tell the student to save the calculated sum into a global variable and provide the correct answer on the lab instructions.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/a-distinct-difference.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&course=&step=13Type of Issue: sort of a bug with reporting out of a for loop Severity: mild Comments: When checking if the numbers are distinct, the instruction says the code should stop in the middle to report false if it encounters a duplicate. However, if the student attempts to iterate through the items of the list with a for loop, the report false in side will fail.

[amrutayel]

Your Name: Amruta Yelamanchili

Overview of Lab Comments: This was a good introduction to runtimes. I think adding more quizzes to this lab would definitely be beneficial to students to test their knowledge of the different runtimes. The “timing sum-thing’s up” page had a lot of problems, but they were all only little things.

For specific issues: (you should copy this section as many times as necessary) Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/time-is-of-the-es-sense.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=2 Type of Issue: clarity Severity: minor Comments: What does it mean by “Save the script with the name Timing Framework”? Does it want you to make a block called timing framework, or save this in the cloud/export as XML, and what’s the point of saving it? I don’t think it comes up ever again, and it’s only 4 blocks.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/do-you-have-time-to-add.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=3 / https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/constant-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=4 Type of Issue: clarity Severity: minor, might stop some students from continuing Comments: For the addition problem, many computers will say it took 0 seconds, and students might think it’s not working. It might be worth it just to note the operations were done so fast by the computer it’s like it didn’t take any time at all.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: clarity Severity: minor Comments: It says “sum-thing’s up” is from earlier in the lab, but it is actually from a previous lab.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue:clarity Severity: prevents students from finding code Comments: It doesn’t say anywhere that the blocks for adding numbers up, Gauss and non-Gauss, can be found in the link for inserting numbers into a list. Also, these blocks have a list input on the lab page, but they don’t have a list input in the Snap link. And they should be reporters, but they were put in as command blocks in Snap. Or, it might need to be a command block, but it appears as a reporter on the lab page.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: clarity Severity: minor Comments: Some clever students might see that they can use combine to do the non-Gauss part of this problem. I’m not sure whether this would affect the run time, but it should be noted whether they can use this block, or whether they should use a loop.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: clarity Severity: minor Comments: It says the reset timer block should be put after the “Add all numbers between 1 to max” block, but it should say put reset timer after “INSERT all numbers between 1 and max into numbers.”

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: clarity Severity: minor Comments: It says the reset timer block should be put after the “Add all numbers between 1 to max” block, but it should say put reset timer after “INSERT all numbers between 1 and max into numbers.”

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/a-distinct-difference.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: clarity Severity: minor Comments: The distinct numbers block is a boolean, but the lab instructions suggest it should be a command block.

[chrisk867]

Name: Chris Kilian

Overview of Lab: Overall, I think this lab is well done. I remember doing this lab when I took CS10 and the only parts I really had trouble understanding was why Gauss's law was useful, but I think you guys really cleared it up this year. I also really liked the way you had the activity run in a certain amount of time and then explain the time in the next slide. I especially thought the "Are the Numbers distinct" page was a very good segue into the explanation of quadratic time. The last two pages are very dense in both text and information, and I think that might be kind of hard for the students, but the subject matter is both complicated and important so I think it is necessary. Shortening those two pages and making them less text-heavy risks losing good explanation which only serves to hurt the student, so even though the pages look really hard to get through I think we should keep them the way they are.

Page Link:http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&noassignment=true&noreading=true&novideo=true&course=cs10_fa14.html&step=8

Type of Issue: clarity Severity: minor Comment: The blocks on the top show the Gauss block above the Non-Gauss block but the instructions are to implement the non-Gauss block first. Someone trying to quickly may not read carefully enough and implement the Gauss block first because it's on top. This is very minor but I think it was worth bring up.

[ArielleSpencer]

Your Name: Arielle Spencer

Overview of Lab Comments: Overall really good. Good pace, easily understood even with the math and big concepts.

For specific issues: (you should copy this section as many times as necessary)

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quiz-searching-through-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7

("Self Test: Searching Through Time")

Type of Issue: Grammar?

Severity: very minor inconvenience

Comments: The first sentence says that the algorithms lab when they saw the sorted lists activity was two labs ago, however it is the last lab they did.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8

("Timeing Sum-thing's Up)

Type of Issue: Unclear

Severity: Minor/Moderate

Comments: It says they made a sum of numbers earlier in the lab but they didn't, at least not in this specific. I think this is linked to a different lab but it may confuse students who didn't do/go to the lab this was in or just cause them to be confused as to when previously in this lab they'd made a sum block. Maybe change to "in an earlier lab" or reference the title of that lab directly.

Also, on this page the two images of the blocks have the Gauss version first, then non-Gauss however the text refers to the non-Gauss as the first ("The first block sums up the numbers in the numbers list the normal, "non-Gauss" way") which may be confusing. Continues referring in this order throughout the page.

Also on this page, it refers to "place it immediately after the add all numbers between 1 and max block" but the block is actually called "insert all numbers between and into numbers" The add confused me because I thought it meant a sum block that doesn't exist.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/projects/hangman/evil-hangman.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13

("Homework: Evil Hangman")

Type of Issue: Grammar/confusion

Severity: minor inconvenience

Comments: Under the second paragraph of additional details, it says "in fact, it will probably be in your best interest to start from your project that you submitted as Homework 3," however this is homework 3, Regular Hangman was Homework 2. Just have to switch the number!

Also, it refers to BYOB several times on the page, it may be helpful to replace all those to Snap! just to increase clarity and not confuse students.

Lastly, I remember that we had to do HW3 with a partner. If that is still the case, it may be good to mention that in the description just so they can start thinking about it and can start trying to pair up.

[jeeves833]

Your Name: Lucas Karahadian

Overview of Lab Comments: This was a good introduction to algorithmic complexity, the examples that we have the students make regarding the different algorithm times are particularly nice. Only a few minor issues detailed below.

For specific issues: (you should copy this section as many times as necessary)

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/time-is-of-the-es-sense.html Type of Issue: Potential lack of clarity Severity: minor inconvenience Comments: I’m not sure if it’s due to most of my experience in this framework being in BYOB, but at the bottom of the page where it says to save the script, my mind immediately asks if you want to save it as a block or to actually save the file into the cloud. Again, not sure if it’s a problem on my end but yeah.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html Type of Issue: Consistency check Severity: Could be really confusing. Comments: The pictures in the lab show the add all numbers blocks as reporters. But when I opened up the the variables menu of the framework given earlier, the two blocks are actually command blocks. The only problem I could see this causing is if students are searching for blocks by shape they may take a bit longer to find these two. In addition the pre-given command blocks do not have any inputs.

[rxia752]

Rowena Xia Overview of Lab: This lab overall is a nice length that conveys a sizable amount of information while also being doable within the time of a lab. I thought the explanation for the Gaussian method was very clear which is very good. There are some pages with blocks of text that might be a problem because I can see students just skimming through them or skipping them altogether. I think it would be good to include little quizzes on those pages with just text both to keep the students' attention and because runtimes is a good and important subject for quiz questions.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=8 Type of issue: Inconsistency Severity: Major (potential for confusion) Comment: In the text, the two blocks are shown to be reporters; however, in the Snap file, the two blocks are commands, which could really confuse students. Additionally, the command blocks in the file don't even have an input. Students should ideally know that they need to add an input but no matter what the discrepancy between the text and the file is not a good thing and needs to be fixed.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/a-distinct-difference.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=10 Type of Issue: Clarity Severity: Medium (potential for confusion) Comment: In the file, and in the picture in the text, the "is distinct numbers" block is a boolean, but the text itself implies, at least to me, for it to be a command block. This part needs to be clarified.

[333lisajin]

Lisa Jin:

Overview of Lab Comments: i.e. i think this lab is pretty good. In terms of the contents, it starts with something interesting and makes math less boring which is good. I find this lab is very easy to understand as well. So in general, this is a pretty good lab.

For specific issues: Page Link:https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quiz-searching-through-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7

Type of Issue: i.e. Since at the beginning, it mentions two labs ago, it should be a good idea to contain the link of the labs that it refers to so that students can go back and check if they do not remember what the content was about two labs ago.

Severity: i.e. Making confusing

Comments: Just add the link of the lab would be good.

[tcabs17]

Tori Cabot

Overview: This lab is a good lab overall. There is a lot of reading and there is not that much work to be done in SNAP!. Because of these two things, the lab would benefit by having more interactive quizzes. Bullet points also help a lot in making the lab a little less intimidating. There are also some places, especially in the Sum-Thing's Up section, where the language is confusing and the explanations are not consistent with the starter code provided in SNAP!.

Specifics: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=8 Type: consistency Severity: moderate Comments: In the instructions on the CS10 website, lab 7 shows a picture of two reporter blocks on the Sum-Thing's Up page. However, when you go to variables in SNAP!, the blocks that are there are command blocks. This may confuse students who do not have a firm grasp on the difference between the two. Some students may not know how to proceed.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/a-distinct-difference.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=10 Type: clarity Severity: moderate Comments: On the Distinct Difference slide, the instructions say to implement the boolean block that the student just created. It then says, as a hint, "Also, modify what Alonzo says at the very end of the script to subtract the extra second that he uses to tell us whether the numbers in the list are distinct." Although this does sort of lead students in the right direction, the way in which they are supposed to implement the block should probably be made clearer.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=8 Type: clarity/consistency Severity: minor Comments: In the Sum-Thing's Up section, the text references a block that was supposedly made earlier in the lab called "sum of numbers between 1 and max". The instructions of this lab did not dictate to create that block.

[mfujimoto]

Your Name: Mason Fujimoto

Overview of Lab Comments: I thought this was a good lab overall. I am concerned that the length may be too much. I foresee some of the concepts requiring time to process which may lead to students feeling rushed. Perhaps it would be appropriate to emphasize that it is okay not to finish the lab and to focus on understanding the concepts. Also, I think diagrams for the quadratic and logarithmic run times would be very helpful for understanding the issues in addition to the text.

For specific issues: Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/logarithmic-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=12 Type of Issue: typo Severity: minor Comments: The last sentence of the first paragraph, “However, the eternal question: Can we do better?” should have a verb in the first clause. A fix would be “However, the eternal question remains: Can we do better?”

For specific issues: Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/linear-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=6 Type of Issue: clarity Severity: minor Comments: The last sentence of the first paragraph reads: “We call these algorithms linear-time algorithms, because if we were to plot the runtime of one such algorithm against the size of its input, we would get a line.” The word line is vague (in math a line is straight, but in art and common language a line can also be curved). I think it would be best to say “straight line.”

For specific issues: Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/constant-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=4 Type of Issue: clarity of language Severity: minor Comments: The last line reads: “Constant-time operations are the Holy Grail of computer science algorithms, and unfortunately, most algorithms are not constant-time, as we will soon see.” The first fragment of the sentence is a positive assessment (…are the Holy Grail), while the second part is negative (…unfortunately). This means that the two clauses should be connected by a contrasting conjunction (e.g. but). A corrected version would be “Constant-time operations are the Holy Grail of computer science algorithms, but unfortunately, most algorithms are not constant-time, as we will soon see.”

[gingerengel]

Ginger Engel

Overview of Lab Comments: i.e. Was this lab good or bad? Too fast? Too Slow? Does it need something new? The intro slides were good. The concept was clearly defined and gives the students a good background for what they will be doing. The difference between a constant time and a linear time was clear and understandable. I did not see any typos or have any issues with clarity. It may have gone a little too slow. The reading to practice ratio was a bit high, but it contributed to my understanding of the lab.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quadratic-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of Issue: Speed Minor Comments: I found this page a bit hard to understand since it was so much text.

[strollinghome]

Carlos Flores

The lab had a couple pages that included huge blocks of text. At the beginning it can seem intimidating for students especially if they are new to the ideas introduced. Other than that the exercises were illustrating and simple enough for the students to understand the main idea.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/logarithmic-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=12 Type of Issue: clarity. Minor. Comments: we should probably mention at some point in this page that we use log base 2 in computer science.

[Laralinmcc]

Lara McConnaughey

Overview of Lab Comments: i.e. The lab was well paced and very detailed which is needed when learning about algorithmic complexity. The only problem I see is that if a student skips any part of the reading they will be confused on the next part. The analogies were also good.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8

Type of Issue: i.e. lack of clarity Severity: i.e. minor inconvenience Comments: In the lab the add all numbers block is shown as a reporter block and in the snap starter file it is a command block.

[william0cheung]

William Cheung

Overview of Lab Comments: Lab is great and easy to follow. Maybe stress more that the physical time is not as important as the type of time, since they are always going to be observing the Timer on Snap. Also a summary of the runtimes shouldn't hurt at the end. Overall, informative lab!

Specific: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/constant-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=4 Type of Issue: Lengthy Reading Severity: minor Comments: Lots of text here, great content, but may be skimmed over by students eager to get to the programming parts.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: Confusing Severity: Minor Comments: Maybe add a screenshot of what the blocks look like, especially when instructing the students to implement many new blocks.

[yifatamir]

Yifat Amir

Overview of Lab Comments:This lab is not very interactive. There is a lot of reading, and so maybe it would be better internalized if students really had to create blocks for each type of run-time. Like the lab check-off could be reviewing that they came up with at least one block for each run-time discussed in the lab.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/competing-with-young-gauss.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=1 Type of Issue: lack of clarity Severity: poorly introduces the topic Comments: This page could really use a few sentences of introduction. Otherwise the transition from the last page to this one is jumpy and awkward.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quadratic-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=11 Type of Issue: lack of information. Severity: minor confusion Comments: it would be great if you could put here an explanation of how time differs from run-time and how run-time is all relative.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quiz-searching-through-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type of Issue: improvement Severity: lacking quizzes Comments: It would improve the lab a lot if people could fill out quizzes relatively often to see if they read anything in these pages full of text and to see if they're understood it too.

[erikdahlquist]

Erik Dahlquist

This lab is my least favorite yet, with a multitude of issues cluttering an already dry subject. From typos on the very first slide to the code framework not lining up with the slides later, this lab is almost guaranteed to be confusing and could be substantially improved with some clean-up. While there are many slides, I think the length is manageable.

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/a-non-video-game.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=0 Type of Issue: Typo. A glaring typo. Severity: Minimal, relatively Comments: "Are there other stragtegies you can think of?" Stragtegies? Really now?

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/time-is-of-the-es-sense.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=2 Type of Issue: Strange wording Severity: Minimal Comments: "Activate (tick-mark) the timer reporter and..." should perhaps be rewritten as "Activate the timer reporter (click the small grey box to its left) and..."

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/do-you-have-time-to-add.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=3 Type of Issue: Lack of clarity Severity: Moderate Comments: Students were confused as to why the timer in this section reported such an insignificant number (~0 seconds). They thought this was an issue. It could be clarified that this is not actually wrong. They also weren't sure whether they should just add one to these numbers with operators, or iteratively add one to itself that many times.

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/quiz-searching-through-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: Incorrect reference Severity: Minor Comments: "Two labs ago, you saw a few different approaches to the important problem of searching..." should read "One lab ago...", as algorithms was the previous lab.

Page link:https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: Incorrect reference Severity: Minor Comments: While it says "Earlier in the lab, you made a block that returned the sum of numbers between 1 and max...", this block was actually created in Lab 4, Abstraction Revisited.

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: Discrepancies in provided framework Severity: Moderate Comments: The framework and slides don't line up very well. The slides, for example, treat the provided blocks as reporters in its pictures, but they're commands in snap and in the text instructions. It's confusing.

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/a-distinct-difference.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: Snap Bug Severity: Moderate Comments: Not a lab-specific issue, but I and another student I was trying to help were unable to make the "are the numbers of (list) distinct" block using "for 'I' of (1) - (10)" blocks. I had to switch to standard repeat blocks instead. I'd guess the index variables of the blocks were getting confused, even though I had renamed them.

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/a-distinct-difference.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: Lack of clarity Severity: Minor/Moderate Comments: "Replace the "Gauss" block from the previous section with the 'are the numbers of list distinct? block that you just made'" is potentially confusing command because the 'distinct list' block is a boolean, while the Gauss block is likely a command block.

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/logarithmic-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=12 Type of issue: Incorrect Reference Severity: Minor Comments: "Two labs ago, we looked at a few ways of finding a number in a list." Again, that was one lab ago, not two

Page link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/projects/hangman/evil-hangman.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13 Type of issue: Ummm...misplaced picture Severity: Confusing, potentially amusing. Minor Comments: What's the "Yeah, we don't have that image right here" image doing? I think it's kinda funny, but it makes it look maybe a bit incomplete

[jeffz6]

Your Name: Jeffrey Zhang

Overview of Lab Comments: The lab flowed well except for the time students would spend waiting for things to finish running. Making it so that you didn't create a new list

every time you wanted to run something probably would have saved everybody a lot of time.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/a-non-video-game.html?topic=berkeley_bjc/areas/algorithm-

complexity.topic&step=0&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html Type of Issue: typo Severity: minor Comments: "decide who will be the guesser and the the picker", should be "and the picker"

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/do-you-have-time-to-add.html?topic=berkeley_bjc%2Fareas%2Falgorithm-

complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=3 Type of Issue: bug? Severity: moderate Comments: I always get 0, even if I make the numbers absurdly large. It could depend on the computer, and I don't know how well this will work on the lab computers. Based on

the next page of the lab, all 0's could be the point of the exercise, but it feels like a waste of time

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-

complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: clarity Severity: minor Comments: can we get pictures of the scripts to run? it would be nicer than reading through the text description

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-

complexity.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: clarity Severity: minor Comments: The blocks in the lab image are reporters, but the blocks in the framework are commands. I think they make more sense as reporters

[carenthomas]

Your Name: Caren Thomas

Overview of Lab Comments: Overall thought that the lab was organized well, but could be done much better considering the difficulty/dry-ness of the topic. Definitely felt that the ratio of reading to activity was too high, and in some cases, important concepts were introduced after an activity relating to it was done which interrupts the flow of how labs are usually structured. Regarding the large amount of reading, the actual content is really important, so one thing that could be done is changing the structure of the readings - rather than large bodies of text, organizing some parts into bullet points/lists and bolding key terms, etc. can help students pick out the important details (since most will be skimming the material anyway)

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/do-you-have-time-to-add.html Type of Issue: Lack of Clarity Severity: i.e. Medium Priority Comments: The timer activity for incrementing reports 0 seconds every time because the operation has a constant run time but this can confuse a lot of students, especially if they don't know what to expect about the run time behavior (which is most likely the case). The explanation is on the next page, but during labs many students raised their hands confused (some thinking that the lab itself was not working) so this could be made better.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html Type of Issue: Bug Severity: High Priority Comments: The images for the sum blocks include a list input, while the actual blocks provided in the starter file do not have parameters at all. These should be made consistent to avoid confusion.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html Type of Issue: Bug Severity: High Priority Comments: The images for the lab on the page linked above are reporter blocks, but the starter file includes them as command blocks and this is sure to confuse students. It intuitively makes sense to have the blocks as reporters (since they are calculating the sum of the elements) but having them as command blocks increases the ease with which they can be used for testing. There are clearly pros and cons to both, but the lab should be adjusted to be consistent with one.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html Type of Issue: Lack of Clarity Severity: i.e. Medium Priority Comments: The script for testing is provided in the starter file and students are asked to attach the block that they create, which is easily done for the two sum blocks because they are command blocks. However, integrating the boolean block (isDistinct) is not very clear and could cause confusion with some students. I'm sure they'd figure it out if they think about it, but the clarity of the lab would be greatly improved if a change could be made.

[adambrown13]

Your Name: Adam Brown

Overview of Lab Comments: A lot of the lab was super information heavy without much opportunity for the student to practice they new concepts they are supposed to have learned. Overall, I think that if there was a lot more interactivity within the lab, it would really help the students though the process. It would keep both interested and make sure that they're learning the assignments as they go along

For specific issues: Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/logarithmic-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=12 Type of Issue: Sentence Flow Severity: Minor Comments: Current sentence of the first paragraph should be changed to , "However, the eternal question remains: Can we do better?”

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html Type of Issue: Clarity Severity: Moderate Comments: The images for the sum blocks do not match the layout of the actual blocks. This could throw up a serious road block to students who are trying to match it exactly

[joelterry]

Name: Joel Terry

Overview of Lab Comments: This is a great lab. Snap is great for learning runtime, because of its consistent clock. Gauss' problem is one of my favorite introductory lessons on runtime, as well.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/competing-with-young-gauss.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=1 Type of issue: Grammar Severity: Minimal Comments: "He realized that, adding" -> I don't think there should be a comma after "that."

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/constant-time.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=4 Type of Issue: Lack of clarity Severity: Minor Comments: This page describes addition as a linear-time operation (meaning its performance depends on the number of digits of the inputs), and then calls it constant-time. I think the fact that addition is linear, but often treated as constant could be conveyed a little better, but it's definitely not a pressing issue.

[MicBrain]

Rafayel Mkrtchyan

Overview: I feel like Snap is a perfect language to learn about the runtime. I remember that a lot of students got the lab material very quickly, which is pretty encouraging. Overall the pace of the lab was very good and material was very comprehensible.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/algorithms/timing/timing-sum-things-up.html?topic=berkeley_bjc%2Fareas%2Falgorithm-complexity.topic&course=&step=11 Issue: Students spent a lot of time one this. Comments: Because this problem contains a little bit mathematical logic, some students who "hated" math were struggling on this. But after minor help they got the idea entirely. I believe that for the next semester we can make this a little bit more understandable.

Some final comments on this lab: I think it will be good if we stress the importance of this lab, because students you are going to continue taking computer science class will encounter with the ideas of Algorithmic Complexity pretty often.