Lab 4: Abstraction Revisited

[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.

[Frankgoji]

Franklin Lee

OVERVIEW: This lab covered a broad range of things. While abstraction was the main focus, I felt that it was possible that some things were tacked on because they wouldn't fit on another lab, or other reasons. Particularly, the last page on global variables didn't feel like it fit at all. Also, not a lot of explanation was given on global variables; why does it cause bugs? Why would you need it? I bring this up because I sometimes found students last semester who kept on using global variables, probably because they did not know how it could mess up their code. Otherwise, I thought the lab was thorough. It may have been on the long side for some students, but it was well-balanced.

(SPECIFIC ISSUES) Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/composition-of-reporters.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=2 Type of Issue: grammar Severity: minor inconvenience, may cause some misunderstanding Comments: The language of the first sentence ("Using similar methodology your challenge is...") is a little unclear. A comma after methodology would make it a little easier to understand. Also, perhaps an explanation of what "composing" functions means. While there is a picture right above it that explains exactly what it means, I don't think it would hurt to give a pointer.

Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5 Type of Issue: Lack of Clarity Severity: mild Comments: This page deals with the Gregorian Calendar function. I remember from previous years that this particular problem had some students stuck for a long time, trying to create helper functions but being confused where to put them. Trying to help them was less easy, since they debugging a long function is tedious. I think it would help to have a couple test "cases" that would help them debug. For example, a tricky date that would definitely return false, and a date that would return true.

Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/quiz-different-ways-to-broadcast.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of Issue: bug Severity: mild Comments: No matter which answer you put for question 4, even the right one, the question is highlighted red.

[thorsoch]

Charles Thorson

Overview of Lab Comments: Subjects were pretty clear. The difficulty level rose at a formidable pace, as you reach the mortar so that the student would not be overwhelmed or bored. At the part where it switches subjects from abstraction to broadcasting and global variables, it was a bit abrupt but I think it keeps the student from getting bored of repeating too much of the same idea. It might be better if we can make something that connects the two concepts together though. For example, maybe changing a global variable with a certain process on one sprite’s script, then broadcasting to do another certain process on the same variable with a different sprite, eventually reaching the solution. This might show how one task can be done by two people through abstraction with neither knowing about how the other completes their job. Another thing I felt was that having to simplify the tic-tac-toe maker and the valid-date checker consecutively was a bit repetitive, and tedious since they use basically the same concepts. In terms of the amount of content, I think it is fair, not too short or overwhelming.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc/intro_new/4-abstraction-testing.topic&step=3&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html Type of Issue: minor inconvenience Comment: Although this is a minor note, I thought it would be more user-friendly if the correct answer for sum 1 to 10 was provided in the question to allow students to skip that tiny bit of mathematical tediousness, while being able to be sure that their fixes solved the bug.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type of Issue: typo Comment: Typo. “within in the loop” -> “with in the loop”

[numfah23]

Your Name: Natnicha Vanitchanant

Overview of Lab Comments: Overall, this lab was pretty good and most of the material was presented well and was easy to understand. The lab was a little long (page-wise), but in terms of difficulty, I found it doable because the exercises were not too complicated. I thought the name of the lab, Abstraction and Testing, was a bit confusing. Does “Testing” refer to the second part of the lab after Abstraction (ex. play sound, broadcast, and global variables)? Or does it refer specifically to the “Test Yourself” pages? If it is the latter, perhaps something about the other parts should also be included in the title name.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5 Type of Issue: Lack of clarity Severity: Minor inconvenience Comments: It would be nice to have something like "recall that a leap year is either divisible by 400 or divisible by 4 and not by 100." because some students might not be familiar with the algorithm.

For specific issues: Page Link:https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/abstraction/new-brick-wall.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: i.e. Typo Severity: Minor inconvenience Comments: (one that humans speak to communicate ) <- should not have the space bar before the closing parenthesis.

[tinatu]

Your Name: Tina Tu

Overview of Lab Comments: This lab was good overall, however I found it to be a bit lengthy despite the fact that the problems are doable. I'm not sure if the students would be able to complete the lab within two hours. However, I found the introductions and explanations between problems were clear and helpful in the problems. I particularly liked the portion between "Simple Debugging" and "The Check Block" because it allows the students to practice two methods of debugging: with a visual representation of the output and without the visual representation of the output.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/abstraction/new-brick-wall.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: Clarity Severity: Mild Comments: It would be nice to provide more detail as to how the brick wall problem relates to problem decomposition, just to give the students a reminder.

For specific issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: Typo Severity: Minor Comments: When it says the predicate block is passed through the diamond slot, I knew which slot to which it was referring to, but isn't the slot a hexagonal shape?

[carynbear]

Caryn Tran

Overview of Lab Comments: This lab is pretty straight forward and easy. The only unclear assignment is the valid-date? assignment. It could be clarified that "although there will be more overall code, some of it should be abstracted away so the valid-date? block itself is easier to read". I had this problem when I first did this lab. Also, there can be a tip added to the Global Variables section mentioning that if you make your global vars in ALLCAPS, they're easier to manage.

Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=3 Type of Issue: Consistency Severity: Minor Comments: Start and End are used as the variable names in the text, but x and y are used as the variable names in the code.

Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/simplifying-a-tic-tac-toe-board-drawer-using-functions.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=4 Type of Issue: Convenience Severity: Minor Comments: Why can't we click on the picture to get to the code?

[amrutayel]

Amruta Yelamanchili

Overview of Lab Comments: This lab was good overall, but may be difficult for some students to finish within a lab section, the brick wall problem especially. I’ve found that some students try to finish all of the problems on a page, even if they really should be moving along with the rest of it. Maybe make a note that the additional exercises for the brick wall should be done after the lab, as there are many more important topics later. Also, the lab is called abstraction and testing, but the “check block” is the only testing done in the lab, and it might be helpful to have more examples/exercises on how it can be used.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/input-types-new.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=1 Type of Issue: lack of clarity Severity: i.e. minor Comments: The max block works on “cat” and “dog,” even though it says it has “unexpected behavior.” It should be noted why it works on cat and dog, just briefly.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5 Type of Issue: lack of clarity Severity: i.e. mild Comments: I’m not really sure why there should be more code than when you started after adding custom blocks.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/abstraction/new-brick-wall.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: grammar Severity: i.e. minor Comments: The move block is described as “move” and “Move”.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/variables/global-variables.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13 Type of Issue: lack of clarity Severity: i.e. mild Comments: Having global variables in this lab seems out of place. They are pretty important, and they shouldn't be introduced without any examples or exercises in the contexts they would be used in.

[rxia752]

Rowena Xia

Overview of Lab Comments: This lab was solid, especially in the beginning, guiding the student in the continuation of understanding abstraction. As much as the problems are doable, however, it feels a bit lengthy and I can see a student getting impatient towards the end. At the very least, I feel the content after the quiz questions feel a bit unnecessary. I am not actually even sure what the purpose of the global variables section is at the end. I agree in its importance but it feels out of place. In addition, I feel like the 'More "Message" Passing' section should be placed earlier, when the broadcast blocks are first brought up in the lab rather than placed after the fact.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=3 Type of Issue: typo Severity: minor Comments: In the block for the second problem "Probelm 2" is listed rather than "Problem 2."

Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/quiz-different-ways-to-broadcast.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=11 Type of Issue: Lack of Explanation Severity: minor Comments: If you get the answer right on the first question and the 5th question, there's no explanation. This could be a problem if the student guessed the right answer and now still doesn't now why it's the right answer. Just a brief explanation with a few words would be sufficient.

[tcabs17]

Tori Cabot

Overview of Lab

The lab was good overall. It felt a little piece-meal, jumping pretty rapidly between various topics. The first four pages, The Max Block, Input Types, Composition of Reporters, and Sum-thing's Up were all well written for the intended audience and were appropriate in their difficulty level. The tic-tac-toe board and valid date sections are also a good exercise in abstraction. The Brick Wall problem will probably take the most time out of all the exercises. Perhaps it should go earlier in the lab so students don't feel as if they are pressed for time to finish it. The Global Variables section was also a little rushed. Because there is no exercise that goes with it and because it is the last slide, this information might not sink in as well as we want it to. I have met students who could have benefited from understanding global variables earlier in the course.

Specific Issues

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type of Issue: clarity Severity: inconvenience Comments: An example of the original code without the check block would greatly increase the clarity of the section. Seeing the code with and without the block is a better visualization of how to use it.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=5 Type of Issue: clarity Severity: could prevent a student from making progress Comments: I agree with carynbear that it should be clarified in the Valid-date segment that students are supposed to add code by abstracting it. Right now, the hint sort of points students in the right direction but it could be made a little more explicit to reduce confusion.

[erikdahlquist]

Erik Dahlquist

That is quite a lab! Subjects vary from custom blocks to abstraction for clarity to debugging to sounds to broadcasts to (for some reason,) global variables. I think the difficulty of each exercise is quite manageable, but I think the overall time it takes to do the lab might be too long. Even though this time around I knew pretty much exactly what I was doing, the lab was still lengthy, with some exercises sucking quite a bit of time. I'm looking at you, Brick Wall. While opening my "Brick Wall" file from when I was a student, I realised I never bothered to complete my wall, and I usually had felt fairly confident about the labs. I think the first 2/3rds of the lab do a nice job covering important material, and as a student I particularly appreciated the satisfaction of the "Composition of Functions" and simple debugging. The last 1/3 of the lab, however, felt a bit out of place, especially the global variables. After student's suffer though the brick wall, I don't believe they will put much effort into studying the global variables slide.

Issues!! Mostly minimal, besides maybe size.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/review-max-block.html?topic=berkeley_bjc/intro_new/4-abstraction-testing.topic&step=0&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html Type of issue: Grammar Severity: Probably won't be noticed Comments: "If you need extra help click on the picture above to go to a Snap file containing the code" might benefit from a "," after help.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/composition-of-reporters.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=2 Type of issue: Coding style Severity: Almost definitely won't be noticed Comments: The "Are any equal?" boolean might as well only accept number inputs, so as to match the parameters of the other blocks.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=3 Type of issue: Typo Severity: 50% don't notice, 49% don't care. 1% care. Darn 1%. Comments: "Probelm" instead of "Problem" in the second function

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=3 Type of issue: Style inconsistency Severity: Accidentally toggling "Caps lock". (Not a real problem) Comments: Why do the functions have such inconsistant subtitles? "no subtitle" to "Problem 2" in the front to "buggy version" in the back.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/simplifying-a-tic-tac-toe-board-drawer-using-functions.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=4 Type of issue: Punctuation Severity: It's punctuation. Severity == non-existent Comments: "English" should be capitalized

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5 Type of issue: Lack of direction Severity: Moderate. Actually potentially frustrating Comments: Not a huge fan of how the Gregorian calendar project is set up. It's a good exercise if it's actually done, but the lack of real direction besides "is leap-year" makes it seem very skippable. Moreover, students that actually do try to abstract it can easily screw up the whole thing and find it hard to fix. Could be a problem.

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of issue: Confusing example script Severity: Moderate Comments: You might want to give them a non-buggy Check Block so they can see how it's supposed to be? Instead of having them play with it until it works out fine?

Links: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/intro/snap/test-yourself-go-team.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=10 https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/quiz-different-ways-to-broadcast.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=11 Type of issue: Slide repetitiveness Severity: Having an itch on your leg (Not a real problem at all) Comments: Why have two quizzes on the same topic on separate slides?

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/more-message-passing.html?topic=berkeley_bjc/intro_new/4-abstraction-testing.topic&step=12&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html Type of issue: Missing Alonzo Severity: Minimal. Or extreme if you care about Alonzo. Which, as a human, you should Comments: There's no Alonzo at the bottom of the screen marking how close I am to completion. How am I supposed to know my progress without putting any effort into finding out!?

Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/variables/global-variables.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13 Type of issue: Poorly positioned slide Severity: Significant Comments: Why is global variables here? I think it's unlikely students will even get to here, but if they do, I seriously doubt they will grasp the significance of Global variables due to fatigue from moving through the lab and a lack of context. And global variables are kinda important...

[william0cheung]

Your Name: William Cheung

Overview: Dense lab, lots of good information that is easy to follow. However, with a variety of topics covered in one lab, there may not have been a general flow to it. Whereas

Specific issues:

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/input-types-new.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=1 Type of Issue: lack of clarity Severity: minor inconvenience Comments: In the max block explained, we see a bunch of text, and the student may overlook it. This is especially for the bottom Note, since they would have completed the block and moved on without reading the Note. It should be placed before the final answer code is revealed.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/functions/composition-of-reporters.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=2 Type of Issue: no solution Severity: Minor Comments: The students should ask if their code is written concise enough. so maybe add a solution page to the three practice problems.

Page link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=3 Type: no solution, new block Severity: Minor Comments: For the Sum-thing's up, we are introducing the For block, which may not be the appropriate time. I'll assume that the students will raise their hands for the LA or TA to come check their answers to these practice problems. However, if they are shy or reserved, they may skip this section.

Page link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=5 Type: New concepts Severity: Could prevent student from completing Comments: I think we introduce the custom blocks here, which is essential to competing the Valid-Date part. They might not be sure what these are, so maybe show an example of the helper block to get them started.

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=7 Type: Clarity Severity: Minor Comments: A LOT of text here. Please break into paragraphs to make it easier to read.

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/abstraction/new-brick-wall.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=8 Type: Order of slides Severity: Minor Comments: We are back to drawing things in the middle of the lab, which may or may not flow in the best way.

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/variables/global-variables.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=13 Type: New topic at the end Severity: Moderate Comments: by this time the student has completed all the quizzes and is ready to check out. Then they see Global Variables. Now this slide is very important but to put it at the end may not be the best idea, considering that the student may be restless by this point. Maybe use this slide in another lab? It's pretty out of the blue to introduce global variables here.

[nish2020]

[strollinghome]

Carlos Flores

This lab is great! In fact I think we underestimate the importance of this lab. Students should be fully conscious of what type of data they're working with. Other than that we should cut it down a bit or make some exercises easier since this lab is a bit long. We could provide more partial solutions rather than have students do things from scratch, this way we can keep most of the material.

Issues: Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/conditionals/valid-date.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=5

Type: clarity/confusing The last line that says there should be more code at the end makes it very confusing. If the goal is to make it more abstract there should be less code. The students are supposed to create blocks that contain parts of this script inside with descriptive names, hence by saying that there should be more code we create a confusion. Also it is very vague, where should this additional code be? Why would there be more code?

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type: typo

Import "toools" with three o's.

[maknegana]

Your Name: Michelle Han

Overview of Lab Comments: Overall, the lab was good in that it tried to introduce fundamental concepts and practices in CS (i.e. abstraction, functions, variables) in a easy manner. The lab might be a bit long only because of slight repetition in the exercises or quiz questions. I feel like some exercises might have been a bit too easy(e.g. the house drawing). I understand that it is suppose to be simple as it was to introduce the practice of debugging, but it was a bit too simple to the point where it seemed a bit silly. The ordering of the pages seemed a bit disarrayed where the concepts didn't tie together towards the end.

For specific issues: Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/concurrency/snap/snap-play-learn-broadcast.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=9

Type of Issue: Minor Comments: The abrupt introduction of a new topic disrupts the flow and overall encompassing lesson of the lab (abstraction and functions).

Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/variables/global-variables.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=13

Type of Issue: Clarity Comments: I found the explanation of the global and script/local variables sufficient (probably because I already know what they mean) but while I was lab assisting, I found out that many didn't really understand the concept of global and local variables despite reading the description. Perhaps a more thorough explanation with excercises where they can actually experience the difference in utilizing global and local variables will be nice.

[mfujimoto]

Your Name: Mason Fujimoto

Overview of Lab Comments: Looking through this lab, I felt like it does a good job of showing how and where to use abstraction as well as teaching the basic layout of snap which is important in early labs. One addition I think this lab could use is an example of a mock project that uses abstraction. I think this could be a helpful addition as on the early homework projects (hangman) I saw only a few students use abstraction in planning and creating their project. Those few that used abstraction liberally had better luck finding and fixing errors in their code and understanding the project as a whole.

For specific issues:

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: typo Severity: minor Comments: "You must import toools..." should be tools.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/abstraction/new-brick-wall.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=8 Type of Issue: pacing Severity: noticable Comments: The brick exercise is a tedious but valuable exercise. I appreciate the lessons learned (e.g. abstracting bricks), but I think the amount of time spent on the exercise is not appropriate. I suggest using a starter file with abstracted blocks pre-made (brick, lines, etc.) and structuring the exercise to allow the students to learn the power of abstraction by arranging the blocks without tedious coding.

[adambrown13]

Your Name: Adam Brown

Overview of Lab Comments: I felt that the lab did a good job of going over essentials. It went into a good amount of depth for everything that the course really bases itself on, and makes sure that the student understands the issues. However, the jump from each subject is a bit abrupt, and they all seem to exist in a vacuum. I think it would helpful to show how they can integrate themselves, and each sorta relies on each other.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: typo Severity: Low Written[toools] should be [tools]

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: Student Clarity Severity: Low The first and last questions lack an explanation. This only really effects students who have guessed, but it can still reinforce the answers for those who know the correct answer

[jeffz6]

Your Name: Jeffrey Zhang

Overview of Lab Comments: The content is fine, but I think the lab is too long overall. It goes from abstraction to testing to costumes and sounds and global variables. The lab tries to cover too much and it really shows when the global variable section is only a page with no exercises.

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/debugging/the-check-block.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=7 Type of Issue: ??? Severity: minor Comments: This example seems really contrived and doesn't really make the if->pause all block seem useful. Is there anything better to show students how to make use of debugging features?

Page Link: https://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/variables/global-variables.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassingment=true&course=cs10_fa14.html&step=13 Type of Issue: pacing Severity: minor Comments: The section on global variables just feels tacked on. Global vs local variables is a really important thing to learn properly, but there's nothing here.

[MicBrain]

Rafayel Mkrtchyan

Overview: Overall the content is fine, however I think the lab is a little bit long for just 2 hours. I really appreciate the importance of this lab, because ideas from this lab are very useful for later practical use. Ideas very mostly easy to understand.

Page Link: http://www-inst.eecs.berkeley.edu/~cs10/labs/cur/programming/loops/sum-things-up-debug.html?topic=berkeley_bjc%2Fintro_new%2F4-abstraction-testing.topic&novideo=true&noreading=true&noassignment=true&course=cs10_fa14.html&step=3

Comments: I feel like some students had difficulties in understanding the general logic of this problem. Students spent a long time on understanding this question, which I think was just waste of time. Therefore, I think we need to clarify this problem for the next semester.