Lab 11: Concurrency

[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 specific issues: (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.

[ArielleSpencer]

Your Name: Arielle Spencer

Overview of Lab Comments: This lab was pretty long and definitely one of the more conceptually difficult labs. It was well explained and went at a fair pace so I think it's pretty good, it should be stressed to work with a partner.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 (snap! Modify) Type of Issue: lack of clarity Severity: minor Comments: It uses the term "in lock step" a few times without explaining it. A short description may be helpful in averting confusion.

[333lisajin]

Your Name:Lisa Jin

Overview of Lab Comments: Good lab. I loved this lab. It was so much fun and students can actually learn a lot. And a lot of things in this lab are explained very clearly and it is also fair pace so students can get on track. This is a good preview for a lot of concurrency questions and students will really be thankful to this lab if they ever take 61A. This lab really helps in terms of concurrency.

For specific issues: N/A Page Link: Type of Issue: Cannot find anything. Good lab I think Severity: i.e. "prevents students from continuing", "minor inconvenience", etc Comments: Description of the problem, what can be done to fix it, etc.

[tcabs17]

Tori Cabot

Overview: This lab, and all labs in general, should have more in-lab quizzes. I've been noticing that people in labs skip slides they don't think we are going to ask questions about. For example, a lot of students in my section had trouble setting up the finch because they skipped the first slide telling them how to do it. We should have more "mandatory" quizzes that don't count towards their grade but that you need to take before you can move on in the lab. This lab, more specifically, is very clear. All of the complex concepts are well worded and the multitude of examples are definitely helpful. The lab is, perhaps, a little long but overall students shouldn't have too much trouble finishing it with a little work after lab. Working with a partner is recommendable.

Specific Issues:

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type: code Severity: minor Comments: On the debugging page, the code that comes up when you click on the link is already fixed so that the two "missing" blocks are filled in. The directions ask the students to fix that problem themselves.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=10 Type: code Severity: moderate Comments: On the SNAP! Modify page, the link to the code that is provided does not fill in the stage. I'm not sure if the wording of what the code is supposed to do is unclear or if the code itself is incorrect.

[amrutayel]

Your Name: Amruta Yelamanchili

Overview of Lab Comments: I seemed to find a lot of small problems with this lab as I was going through it. It is pretty short and there is not much code to write, but I guess a lot of the two hours is taken up by the card sorting activity. More quizzes would be helpful in the lab.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: bug/typo Severity: minor Comments: There actually isn’t a bug with this code. It stamps in the upper left corners perfectly fine.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: clarity Severity: minor Comments: What’s the point of saving the nondeterministic code? It isn’t used later.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc/areas/concurrency.topic&step=10&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html Type of Issue: clarity Severity: minor Comments: It should be noted that the wait block should be placed before the warp loop. If it is put inside the warp loop, it doesn’t change the order of which the sprites fill the screen.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-play-2.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=12 Type of Issue: clarity Severity: minor Comments: This should be on the previous page. Students might waste time building the code when the next page already has a link to it.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-script-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of Issue: bug/clarity Severity: minor Comments: If it is deterministic, the lab says finish should always be “123”, but mine is always “321”. It should be noted that there are different possibilities for the output of finish, but they should remain constant for everybody.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-play-3.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=15 Type of Issue: bug Severity: moderate Comments: My results are the same for when the thread safe scripts setting is checked/unchecked. It says when thread safe scripts are off, only the first number gets incremented, but all of the numbers seem to get incremented, just as they do when thread safe scripts is turned on.

[tinatu]

Your Name: Tina Tu

Overview of Lab Comments: I felt like though this lab wasn't too long physically, it covers a lot of difficult concepts, however it does a good job of explaining. So I can see this lab taking a long time for majority of the students.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/overview-snap-2.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&course=&step=13 Type of Issue: i.e. grammar Severity: minor inconvenience Comments: I feel that the last sentence on this page is worded awkwardly, almost like a run-on sentence. Please consider rewording it. I had to reread it few times to make sure I was understanding it correctly.

[numfah23]

Your Name: Natnicha Vanitchanant

Overview of Lab Comments: Overall, the lab was good but involved very little coding. The concepts and ideas relating to concurrency were presented very well with a lot of examples. However, I feel like there was a lot of reading that might take a long time. Also, instead of giving out the answer to questions (ex. What are the possible values of finish if we answer "no"?) on the next page, it might have been more helpful to have the quiz format like in the previous lab (lab 10 fibonacci example). Afterwards, the more detailed explanations can then be provided on the next page.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-machine-concepts.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5 Type of Issue: Lack of clarity Severity: Minor inconvenience Comments: “The programming environment is full of concurrency, implicit (two scripts both start when the green flag is clicked, or when they receive the same broadcast message), and explicit (the launch block).” This sentence is kind of long, it might be better to break it up into shorter sentences like this: “The programming environment is full of concurrency. There are two kinds of concurrency, implicit and explicit. An example of implicit concurrency is when two scripts both start when the green flag is clicked, or when they receive the same broadcast message and an example of explicit concurrency is the launch block.”

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: i.e. Bug Severity: Prevents students from continuing Comments: There isn’t a bug in the concurrency (parallel block)? I ran the example file in snap and it worked fine without missing the first stamps.

For specific issues: 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=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type of Issue: i.e. Lack of clarity Severity: Minor inconvenience Comments: : “Lines 2-4 are the Base Case, in which we handle a situation so simple that we don’t need to call the block recursively”. Instead of saying “a situation so simple”, it would be more clear to say “the most simple situation(s)” since this is technically what a base case is.

For specific issues: Page Link:https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: i.e. Lack of clarity, bug? Severity: Minor inconvenience Comments: "wait (1 / (pick random [1] to [10])) secs”) would look better as a block made in snap so that there aren’t so many parentheses. On a side note, I tried adding this wait block and after running it for about 4-5 times, I always had all of the blocks on the screen filled with blue (but with each 60x60 block having a different wait time), then all gold, then all cardinal, and finally all white (end result would always be the whole screen being white). I’m not sure if something is wrong with the code, there is a problem on my laptop, or if I am misunderstanding this assignment.

[strollinghome]

Carlos Flores

The lab is a little confusing on some parts but that's just how concurrency can be. Overall the examples illustrate the right concepts and although there is room for confusion I don't how we could change it without scraping the whole thing and using different examples.

Specific Issues: The lab says there's a bug where the first squares are not stamped but that doesn't actually happen in the starter file. https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7

[Laralinmcc]

Your Name: Lara McConnaughey Overview of Lab Comments: The lab could be formatted better with key concepts highlighted at the top of the page. The question answer portions of the lab would be helpful if students actually try to answer the question themselves before looking at the answer.

For specific issues: (you should copy this section as many times as necessary) Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/reflection-snap-3.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=16 Type of Issue: i.e. clarity Severity: i.e. minor inconvenience Comments: The first sentence says that there are three possibilities then the box bellow lists 4 points...

[nish2020]

Your Name: Nishchala Singhal

Overview of Lab Comments: Overall, the lab is good and helps students understand concurrency in Snap. The lab is definitely more concept-based than actual programming, which I think may allow students to just skip exercises without actually understanding the material. So, maybe some more actual coding exercises would be beneficial for students. Also, the lab gives the answers to pretty much every question it asks, which could also allow students to skip through the material with actually comprehending it. So, I think it might be useful to not reveal the answers straight away. Lastly, I think the interactive class card-sorting activity is good, as it helps students more easily understand the basic ideas of concurrency.

For specific issues: Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type of Issue: Bug Severity: Moderate Comments: The exercise says that the script should have a bug in it, but it actually does not. This could confuse students and prevent them from moving on.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-machine-concepts.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=5 Type of Issue: Wordiness Severity: Minor Comments: This page has a lot of reading, and students may just skip it. Maybe shorten the explanations?

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-answer-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=13 Type of Issue: Clarity Severity: Moderate Comments: This page (explaining the race condition) might confuse students. I think that the explanation could be a little clearer.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-play-3.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=15 Type of Issue: Bug? Severity: Moderate Comments: In the Multiple Broadcast exercise, it says that there should be different results when the 'Thread Safe Scripts' is checked off versus when it is on; however, I am ending up with the all the numbers in the list as '5' in both modes.

[yifatamir]

Yifat Amir

This lab was interesting overall, and the different demos illustrated the concepts well, but it was not very interactive.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/overview-snap-2.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=9 Type of Issue: too much text Severity: minor Comments: This page (and others in this lab too) is very text-heavy and could be more attractive if they included diagrams and/or code snapshots. This page could for example use images of the "hello from thread #i" in different computing languages, to illustrate how it works across platforms.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-answer-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13 Type of Issue: lack of clarity Severity: minor Comments: the wording of the bullet points on this page isn't very clear. like if "3 joins its 3, finish is now 3" could be rephrased, I think it could make a lot more sense.

[LithiumH]

Your Name: Haojun Li

Overview of Lab Comments: Very interesting lab. Very good paced too. One suggestion would be using one document with multiple sprites rather than 5 different starter files.

For specific issues: Page Link:http://128.32.42.199/~cs10/labs/cur/programming/sorting/cards/card-sorting-discuss.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=1 Type of Issue: Unnecessarily prolong the lab Severity: almost none Comments: Students are asked to write the algorithm down. I believe explaining the algorithm would be good enough since we need not preserve them nor are we grading them.

Page Link: http://128.32.42.199/~cs10/labs/cur/programming/concurrency/snap/snap-machine-concepts.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5 Type of Issue: lack of clarity Severity: medium Comments: There are not a good summarization of models. It makes the student hard to summarized and thus understand them without a keyword.

Page Link:http://128.32.42.199/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: prevent student from understanding Severity: Major Comments: There is no bug in the starter file?! This is a huge mistake and should be fixed as soon as possible.

[jeffz6]

Your Name: Jeffrey Zhang

Overview of Lab Comments: When things don't work the way the lab says they do, there's a big problem. I also thought that concurrency was one of the least interesting ideas in 61c, so I guess I didn't enjoy this one much, though it doesn't have much to do with the quality of the lab

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/sorting/cards/card-sorting.html? topic=berkeley_bjc/areas/concurrency.topic&step=0&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html Type of Issue: time Severity: minor Comments: Please don't ask them to sort the deck multiple times each

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: lack of bug? Severity: minor Comments: I ran it without any changes and there aren't any missing squares

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: possible bug Severity: moderate Comments: after adding in the line "wait (1/(pick random 1 to 10)) secs", I am still getting all one color, and sometimes you get a different color after refreshing the page. Not sure if I'm dumb or this is broken.

[erikdahlquist]

Erik Dahlquist

While I've no qualms with the overall layout of this lab, it's pretty sketchy because (at least for me and Amruta,) almost every exercise has some kind of issue with it, whether those issues be a lack of clarity or pre-fixed bugs. I like the card sorting exercise, I think that's a nice change of pace and does a good job showing the issues that pop up with concurrent operations. Also, my lab with Victoria last year beat Jeff's labs' previous record, so that was a good time. And there's some good variety with the Snap exercises too, even though coding is minimal. But seriously, I ran into so many issues it was weird, and if I was a student in CS10 I would be quite skeptical as to the legitimacy of this lab. Should be fixed!

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/sorting/cards/card-sorting-discuss.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=1 Type of Issue: Waste of time Severity: Minor Comments: Why have them write out their strategy? Especially since a lot of the strategies will likely be pretty similar and simple, I feel like there's not a problem with them just talking their strategies over.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/concurrency-in-real-life.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=4 Type of Issue: Lack of explanation Severity: Minor Comments: You may want to clarify what the "serial" portion of a task is

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-play-1.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=6 Type of Issue: Lack of clarity Severity: Minor Comments: Might want to clarify that in order to reset the program you'll need to hit the red Stop sign first.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: Lack of bug, lack of clarity... Severity: Moderate Comments: There's no bug here for them to fix, the corners are stamped properly. This is confusing and takes away some coding/debugging from them.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: Confusing terms Severity: Minor Comments: Might want to clarify what "lock step" is

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: Misleading instructions Severity: Major Comments: Following the instructions as stated won't change anything. You need to either remove the warp block before you put in the wait block or put the wait before the warp to see a difference. This is very confusing.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 Type of Issue: Unnecessary task Severity: Minor Comments: Why are we having them save this? They'll never use it again, and if they followed the lab's instructions it's not working properly anyways...

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-script-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of Issue: Confusing slide formats Severity: Moderate Comments: This and the next slide should definitely be merged. The following slide has very little substance, but contains the starter file for the current slide and should thus be placed with the current slide.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-script-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of Issue: Slides/Snap not lining up Severity: Moderate Comments: While the slides insist that answering "yes" will make finish "123", in reality answering "yes" results in finish being "321". This is confusing

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-answer-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13 Type of Issue: Awkward slide formatting Severity: Minimal Comments: This slide would be more readable if the 1st and 2nd points were formatted like the 3rd, with the explanation box on the line after the statement.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/reflection-snap-3.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=16 Type of Issue: Slides/Snap not lining up Severity: Major Comments: For me there was no difference in the program's outputs whether "Thread Safe Scripts" was on or off (though without TSS it seemed to struggle a bit more). This is confusing and not very good for proving that "Thread Safe Scripts" is important...

[carynbear]

Caryn Tran

Overview of Lab Comments: This lab is useful for people who might want to use multiple sprites/parallel threads in their midterm or final projects. That should be emphasized when students do this lab.

Page Link: http://beautyjoy.github.io/bjc-r/cur/programming/concurrency/snap/snap-machine-concepts.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=5 Type of Issue: Improvement Severity: Low Comment: Here would be a perfect place to bold the concurrency problems and have side by side pictures depicting them. It's relevant considering it's one of the lab check off questions

Page Link: http://beautyjoy.github.io/bjc-r/cur/programming/concurrency/concurrency-in-real-life.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=4 Type of Issue: Clarity Severity: Medium Comments: I had to read this a few times to understand it. "With a partner or in a group, please share a non-computer, real-life example in which the serial portion of some task is the smallest (i.e., embarassingly parallel) and is the greatest (i.e., most difficult to parallelize)." This sentence could be rewritten with more clarity as: "Share two real-life (non-computer) examples of concurrency with a partner or group:

1. The first example should have an extremely small serial portion (and a conversely large parallel portion)
2. The second example should have a extremely large serial portion (and a conversely small parallel portion)"

Page Link: http://beautyjoy.github.io/bjc-r/cur/programming/concurrency/snap/reflection-snap-3.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=16 Type of Issue: Formatting Severity: Low Comments: The text says there are 3 possibilities and then in the box there are 4 things numbered (the last item is actually not a possibility, so put that in bold and unnumber it!)

[maknegana]

Your Name: Michelle Han

Overview of Lab Comments: I felt like this lab was a conceptually loaded lab. Although the excercises (hands on and in Snap) kept students actively engaged, I also noticed that many people were just going through the motion or just skipping slides. Because the concepts of this lab is difficult, I feel that the lab should be shorter so as to be less stressful for the students. I liked how the lab was structured(easy on the eyes/not blurbs of text), especially "These are the Possible Values" slide as it was easy to understand. I can tell that the Lab developers really worked hard on structuring this lab.

For specific issues: (you should copy this section as many times as necessary) Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: i.e. lack of clarity Severity: i.e. slight confusion Comments: There is no bug for the students to fix... Link:https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-script-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of Issue: Graphics Severity: really minor Comments: The block graphics are stretched out and a bit blurry. I know this is a minor problem but it bothers me a bit when looking at the code. Perhaps fixing this will just look nicer and be a bit easier for the students to read.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-debug.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7, https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-modify.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-play-2.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=12 Comments: Too many files to open. Perhaps have it under one Snap File.

[mfujimoto]

Your Name: Mason Fujimoto

Overview of Lab Comments: I felt like this lab left a little to be desired. I term of concepts I think it is great. Some of the material on the tests are very similar to these exercises and I think students appreciate the transparency in that regard. However I would like to see this lab stray from the conceptual level and try to address problems that programs in real life and in snap face. As students continue in the semester and work on non-idealized projects with multiple components running at once they run into concurrency problems. I don't feel like this lab prepares them for the application of their knowledge in practice. Overall, I would like to see more quizzes/ examples that allow students to test and apply their knowledge on a less conceptual level (i.e. in their projects and in understanding computer programs).

For specific issues: Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/read-and-finish-with-n-answer-snap.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=13 Type of Issue: clarity Severity: considerable Comments: I feel that this page could really benefit from some reformatting and rewriting. Combinatorics is hard for me personally to understand without looking at something and this page is sadly just text. I suggest finding suitable images or even a video to augment the text.

[MicBrain]

Your name: Rafayel Mkrtchyan.

Overview of Lab Comments: The first thing I noticed about this lab was really long compared to some other labs. Also because ideas discussed in this lab are very important, this lab should provide more attention and clarity in explaining those concepts.

For specific issues: Explaining the definition of parallelism and why programmers need that.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-machine-concepts.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5\

Page of Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/reflection-snap-3.html?topic=berkeley_bjc%2Fareas%2Fconcurrency.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=16

Type of issue: Very broad explanation and lack of clarity.

Severity: I can guess that a lot of students will have trouble understanding the information provided in those two links.

Comments: I think we should spent more time on explaining the real definition of parallelism and its use in modern technologies. More real world examples would be important, because those instances would highlight the importance of parallelism. For the second link, bringing small examples for each statement would be more helpful.