16. Besides Blocks: Data Structures in Python (LA Review - Sp15)

[lmock]

Your Name:

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

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

[amy97]

Your Name: Amy Vatcha

Overview of Lab Comments: This lab took me much longer than the allotted time. Comparing python code to snap code throughout the lab is very helpful as it helps students to relate python to what they have been learning throughout the semester. However, the exercises for the student to complete start very late in the lab so the large number of concepts introduced in the beginning of the lab all at once may seem overwhelming

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/lists_intro.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: lack of clarity       Severity: minor inconvenience       Comments: At the bottom of the page in the green box, the : is explained. In my opinion, it would be helpful to pose a question to the students about how to use the double colon, check each item of the list backwards etc.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: lack of clarity       Severity: minor inconvenience       Comments: Maybe putting the definition of mutability at the top of the page instead of at the middle would be more helpful since then the student can look at the examples and understand each one rather than reading the examples without a concrete definition of mutability

[18epedersen]

Emily Pedersen

I think this lab has so many great examples of manipulating lists and data, but the format of this lab might be too overwhelming. This beginning pages of the lab throw a lot of information at the students, and then the students, given so much information, have to piece together which information is relevant to solving a particular question. I suggest either cutting this lab in half or spacing out the information pages with pages that ask students to build something. I also think that the idea of mutating a list and creating a new list should be stressed more because as a CS10 student I didn't really understand that concept, and now as a student in CS61A that concept is very important to understand for environment diagrams.

[Justin-Kim72]

Name: Justin Kim

Overview of the Lab Comments: This lab to me is one of the most important labs in terms of learning python, because like Emily Pedersen said, you use a lot of these basics in the cs61a class and for those wanting to pursue a CS major after this class needs to understand that this lab is pretty important. I like the comparisons between the SNAP! program and python. It is a lot of material in the beginning, but I think it's fine to do it that way, because you are going to have to learn all of this at some point. The exercises might take a while considering that python will be new to them and understanding how to interpret the concept and turning it into python code might be difficult. Other than that, good lab to work on and explained very well.

[anushasyed]

Anusha Syed

I think this lab has a lot of valuable information and the exercises are really helpful for students who plan to take 61a in the future. I also agree that the snap to python diagrams are extremely helpful, but I think it would also be nice to have a footnote somewhere (since this is a fairly challenging lab) that if you are confused, try building it in snap! first then try converting it into python code. I found this lab really confusing at first, but when I saw that the snap thought process was the same, python became a whole lot easier to understand. Although this lab is pretty time consuming already, I think it would be really helpful to have some (optional?) practice problems on basic list mutation/dictionaries because the problems with dictionaries (particularly find player) are pretty difficult without some prior practice. Overall, this lab is really valuable, and the exercises really help with understanding some core concepts of python employed throughout 61a.

[frankyguerrero]

Your Name: Rocio Guerrero

Overview of Lab Comments: The lab exercises are definitely a lot more challenging compared to the first Python lab, but the instructions and explanations are straightforward and very informative, which really helps in going through the lab. The lab also builds up its difficulty level at a good pace so it doesn't intimidate the students too much too quickly and keeps them engaged in the material. I still like how you continued the Snap-to-Python comparisons which allows for an easier transition between the two programming languages. This also helps the students realize the importance of mastering all the concepts learned in Snap to be able to tackle Python appropriately and the strong similarity of both languages. The material was really useful especially for students thinking of doing 61A. The pictures of the terminal were also very helpful in understanding the purpose of the code being introduced.

[sayabe]

Your Name: Satoko Ayabe

Overview of Lab Comments: I think the lab gives students a great introduction/advantage for lists and list comprehensions. This lab really helped me out a lot with CS61A this semester.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: i.e. lack of clarity       Severity: i.e. minor inconvenience       Comments: I think it'll be helpful to students if we include the zero-indexing chart (the box diagram where the indices are between the numbers)
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_hofs_comprehensions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: i.e. lack of clarity       Severity: i.e. confusing for students?       Comments: instead of " [x for x in my_list if function(x)]", i think it'll be clearer to write something like [f(x) for x in lst if <predicate (x)>]

[cynthiaha]

Your Name: Cynthia Ha

Overview of Lab Comments: I think this lab is really useful, especially for students who are looking to take CS61A next semester! The difficulty builds up as the lab progresses, which makes the pace of the lab manageable. This lab was definitely time consuming when I did the course as it was only the second lab of python, so it is good that there is a catch up lab afterwards. The length of the lab may be a bit overwhelming since there is a lot of content on lists and dictionaries. It would be helpful to stress that it is normal that students may not finish in 1 lab (or maybe it would be less stressful for students if the lab was split into two - lists and dictionaries).

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_functions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html

Type of Issue: suggestion

Severity: minor inconvenience

Comments: It may be useful to show them the "remove" function too

[eurieoh]

Your Name: Eurie Oh

Overview of Comments: This lab provided great practice with Python. It was a little more challenging than the last lab, so they were given the opportunity to challenge their understanding of Python.

-- [] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: image problem Severity: minor Comments: The image of the list of the Beatles names is strangely cutting off the last name in a way the Snap! wouldn't do. When I tried accessing this lab, the following page also had similar problems when trying to display the image of lists as given by Snap!

[mikomwang]

Your Name: Michael Wang

Overview of Lab Comments: Great lab overall. The practice problems were solvable, and honestly, who doesn't like learning about dictionaries and lists?

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/lists_intro.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: Clarity       Severity: Minor       Comments: I think it should be made clear that in Python, indexes start at 0. Additionally, it should be made more evident as to how list splicing works. More list splicing problems (maybe with step introduced) could actually be potentially given as exercise in this lab, because I remember how one problem on the final looked something like [::-1] and I know a lot of people were confused about how to approach that sort of question.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: Clarity       Severity: Minor       Comments: I really like the explanation how a change in "beatles" affects a change in "names" because they point to the same list object. However, maybe like a small diagram can be drawn to illustrate how they're bound to the same object and not copies of each other. (Maybe it can be taken further and introduce python concepts like if a = b, then (>>> a is b), (>>> a == b)?)

[michen-ml]

Your Name: Michelle Chen

Overview of Lab Comments: The lab is pretty clear. I think in the future maybe go over the idea of mutability a bit more because that was a confusing topic for me. Adding practice questions about mutability might help. Overall a well-structured lab.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_hofs_comprehensions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: clarity       Severity: minor       Comments: maybe adding a general list comprehension model for map and keep combined would help since there is one for map and keep individually.

[mayaah]

Your Name: Maya Angelica Hernandez

Overview of Lab Comments: This lab seemed pretty long and daunting, especially with the challenge exercises most students wouldn't be too keen on doing, it feels like they're missing out if they don't do them. However, this lab covers important topics on lists and dictionaries and even I learned new things. As the lab says at the end, hopefully this lab does not frighten students away from Python.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&course=cs10_sp15.html&novideo&noreading&noassignment       Type of Issue: lack of clarity       Severity: minor inconvenience       Comments: The line "Changing lists needs to be done with care. In Python, when a list is "copied" to another variable, the list is not actually replicated, both variables now simply point to the same list." Because I've gone on in the 61 series this sentence makes sense to me, but if these were new concepts to me, variables "pointing" to the same list seems like an odd concept. What helped me in 61a was seeing diagrams of the variable names with actual arrows pointing to the same list. But I don't know how necessary that is here.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_functions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&course=cs10_sp15.html&novideo&noreading&noassignment       Type of Issue: lack of clarity       Severity: minor inconvenience       Comments: The last line: "Note: in Snap the delete block does not return the list item that is deleted, while Python's .pop() function does return the item that it removes." A concept I struggled with for a while entering snap was the idea of "return". I don't recall the definition of this being discussed so far in the labs. For instance, there is a difference between returning and printing a variable and there is a difference between "showing" and saying a variable. It might be confusing to students what return really does and why Snap's delete block does not return.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/2D_lists.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&course=cs10_sp15.html&novideo&noreading&noassignment       Type of Issue: information       Severity: inconvenience       Comments: I initialized a new list in this exercise but I don't recall students learning how to initialize a list in python, in the labs at least.

[yifatamir]

Yifat Amir

Overview of Lab Comments: This lab is fun and has quite a bit of new information! I think it might be hard to finish in 2 hours, but jut depending on how comfortable students feel transitioning from snap to python. I really like this lab! (also, the jokes are good)

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/lists_intro.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: lack of clarity       Severity: prevents students from continuing       Comments: I think we should include on this page an explanation of zero-indexing so that the images all make sense.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: needs summarizing       Severity: may cause future confusion       Comments: At the bottom of this page, we should summarize mutability and the difference between assigning another name to the same object VS copying that object.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_functions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: lacks clarity       Severity: may cause future confusion       Comments: in the top of the page, we say "This function cannot be called alone." but we don't explain dot notation at all. I think we should add a few sentences explaining how the list object has this function that it can call on itself to modify itself (or something along those lines). Students have never seen dot notation before, and it doesn't explicitly exist in snap really...
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/2D_dictionaries.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: typo       Severity: very minor       Comments: in the first paragraph, it says " keys. so" instead of "keys, so"

[susanshen96]

Your Name: Susan Shen

Overview of Lab Comments: This lab gives a pretty good introduction to more complex material of Python, even though some of the questions may be difficult to solve at first. The beginning of the lab gives a good overview of the tools needed for analyzing dictionaries and lists, and for implementing lists. However, some of the questions, especially the ones that ask to manipulate nested lists and to implement recursion, may be difficult to grasp. It might be helpful to add a few tips/hints to some of the challenge questions so that if students are having a hard time, they have an idea of what to do.

[ilinabg]

Your Name: Ilina Bhaya-Grossman

Overview of Lab Comments: This lab was relatively straight forward. I felt like the mutability slide could have been a little clearer, just because I think that mutability can be a bit of a difficult concept to grasp (and because it shows up in the dictionary section). Another concept that was glossed over was the iterable versus iterator which I feel should be described in more depth. The notes in orange on each slide are very helpful and maybe should be added to more of the sections? I think that the most difficult exercises in this lab are the nested lists and dictionaries so if there was more information on these topics I feel like students would feel more comfortable doing the exercises. Otherwise, I think that this is a really great lab that isn't inordinately difficult if students read all of the text.

[megancarey]

Megan Carey

Overview of Lab Comments: A good lab, with reasonable pace

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: just a suggestion       Severity: not a problem!       Comments: I think that in the passage that describes list mutability and variable assignment, it might be useful to use a box-and-pointer diagram to explain the differences between list and value variables.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_hofs_comprehensions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: another suggestion!       Severity: not a problem!       Comments: In the description of the keep function in python, it might be helpful to establish that this is called a list comprehension so that students know how to recognize it.

[danielduazo]

Daniel Duazo

Overview of Lab Comments: I like this lab as a introduction to dictionaries, HOFs, and mutability, as well as list of lists. I noticed list of lists were not commonly used in Snap but are a big part of Python. I would have liked to have seen some sort of box and pointer diagram that can help explain mutability because I know mutability might be something that students have trouble grasping. Overall, the pace is good for a 2 hour lab.

[bitofbreeze]

Your Name: Florin-James Langer

Overview of Lab Comments: Good lab, but it seems a bit long with a lot of info packed in. It could be beneficial to split this into two labs.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/llab/html/topic.html?topic=berkeley_bjc/python/besides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: typo       Severity: not       Comments: In the last bullet in Big Ideas, efficient is spelled as "effecient".
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: not most effective way to teach terms       Severity: terminology       Comments: It;s a very subtle thing, but in "Conversely, a string is not mutable (immutable).", you should say, "Conversely, a string is immutable (not mutable)." instead, so that the student is encouraged to learn the term immutable instead of putting it as a side-thought. It is also more consistent with the previous sentence.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: not an issue       Severity: not       Comments: Here, "To make a true separate copy of a list, use the [:] operator.", you should also mention the list function, which does the same.

[morganewing]

Your Name: Morgan Ewing

Overview of Lab Comments: Overall, I think this is a very difficult lab which introduces many different topics. I think that many students will be unable to finish the entire lab in one lab period. If possible, I would suggest splitting this lab into two parts in the future. However, I think everything is thoroughly and effectively explained.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/data_structs_getting_setup.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: lack of clarity       Severity: minor       Comments: Maybe there should be something that says that the challenge exercise is optional to make sure students don't spend too much time on it.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/data_structs_getting_setup.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: typo       Severity: minor       Comments: On the starter file, substitute_sequences is misspelled.

[juliaalcaraz]

Julia Alcaraz

Overview: I really like this lab because it teaches the main differences between Snap and Python, while also explaining what data structures are, what mutable functions are, what iterators and iterables are, higher order functions in Python, and dictionaries which I believe are very useful to understand from the beginning. I also like that it first explains most of the fundamentals and then begins introducing exercises for the students to try, I feel this method gives them time to understand the information before they tackle on a question.

http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_iterators.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html

Minor issue, on this page at the top, where range is mentioned maybe add a note that emphasizes the fact that range in python is exclusive of the end parameter. It is demonstrated in the Snap! equivalent but it is not pointed out.

[KamikazeTomato]

Your Name: Henry Chung

Overview of Lab Comments:

Overall I liked this lab much more than the previous lab. In many ways it felt like this was more of an introductory lab then the one preceding it. The individual concepts were explained and illustrated well with ample amounts of callbacks to SNAP. I think the lab needs a little more information in regards to what an iterable is. I think the lab can benefit from just a little more handholding in certain parts, like how to access items in a nested list.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_functions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: Error       Severity: i.e. Inconvenience       Comments: The example for "pop" is flawed. On the Snap parallel example it simply has the remove part of "pop" but not the fact that pop also returns the removed item.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_iterators.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: Lack of Clarity       Severity: Inconvenience.       Comments: There should be more explanatory text explaining iterables or at least how the for loop goes through each individual component of a list or string. The concept seems confusing and prone to just a cursory understanding.

[xmhjch]

Your Name:Jiachen Hu

Overview of Lab Comments: This is also a very interesting lab. It is not very hard and it eases people in. The exercises are quite manageable, but the syntax problem will keep bothering students. This lab would probably be a long one and I don't expect a lot of them to finish on time. Overall, its a very useful lab with clear instructions.

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

• [ ] Page Link:http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_hofs_comprehensions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html

      Type of Issue: lack of clarity       Severity: might prevents students from continuing       Comments: Students might not know how to transform list into string

• [ ] Page Link: N/A

      Type of Issue: bug       Severity: prevents students from continuing       Comments: The file "PythonLab2" presented has a lot of indent problem in returns that might result in the error "unindent does not match any outer indentation level"

[carolinekim]

Caroline Kim

Overview of Lab Comments: The lab does contain a lot of material. A lot of new information from dictionaries, list comprehension, HOFS in python, and etc. are all included in this one lab. It might be a little difficult for the students to complete the lab in one sitting. However, one of the awesome things about this lab is that the pages display the comparison of the new python code to the Snap! code that the students are familiar with. Through the comparison, the students should be able to relate the new information to what that have already learned and mastered. Overall, if the lab materials are split into two separate labs so that the students can really take their time going over the material and trying out the problem sets, I think it would be better.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: Lack of clarity       Severity: Minor inconvenience       Comments: On top of the page, when replacing the 4th item of the names list, the lab instructs the students to use names[3] = "Ringo". Since the students are still new to the idea of 0-indexing, maybe leaving a side note staying that names[3] is actually the 4th item of the name list might help students that are still confused and not used to the idea of 0 indexing.

[papratt]

Your Name: Paige Pratt

Overview of Lab Comments: This lab is very good at explaining and describing everything. I remember the exercises were a bit tough at first but the lab gives students all the material they need to figure out what they need to. They only thing I have an issue with is HOFs. In CS10 they are explained in a very different was as apposed to cs61a and other cs classes I wonder if teaching them in a different way might be more helpful. Of course this change would have to be implemented earlier in the course but I am noticing it now. Overall I think it is a pretty good lab and does a good job of explaining the tools you can use in python.

[soham14]

Your Name: Soham Kudtarkar

Overview of Lab Comments: This lab, although it did not have very many new and complex ideas, was a bit long; however, I feel that all of the information given in the lab was necessary. One idea to cut down the length of time for the lab might be to create less challenging or time-consuming exercises. Other than this, however, I found the lab to be very effective in teaching data structures! This lab paid attention to both the big ideas and the details of data structures, and was very instructive.

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_hofs_comprehensions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: typo       Severity: minor inconvenience       Comments: In the example at the bottom of the page, the final item in the list ["CCGTTCGTCC", "CTCGCGTCCGCCCGC", CCGTTCCGCTG"] is missing a quote on its left side.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/2D_dictionaries.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: typo       Severity: minor inconvenience       Comments: The sentence "only immutable objects can be dictionary keys. so things like strings..." has a period after the word "keys" when it should not.

[JiazhenChen]

Your Name: Jiazhen Chen

Overview of Lab Comments: This is a pretty good intro lab to the list attributes in python. It's in good pace but a bit long. I think we can suggest the students to do the challenge one later, after they finish the lab, in case they don't have enough time. Also, since there're so many functions that we've mentioned through out the lab, I feel it's necessary to make a summary list for all these functions at the end of the lab, which is much easier for the students to refer back when they need to do reviews.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/lists_intro.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: page layout       Severity: minor inconvenience       Comments: For the "to join list together" part, the python code picture seems to have som problem. When I zoom in or zoom out, the amount of lines will change accordingly and the code is hard to read.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_iterators.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: page layout       Severity: minor inconvenience       Comments: The same problem in the previous issue. The second python code picture changes as I zoom in and out and becomes hard to read.
• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/2D_dictionaries.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: clearity       Severity: minor inconvenience       Comments: I feel like for the final band question, we shall remind the students of the difference in the variables' name (as we use instrument and insturment). Also this is a good place to remind the students that the names for variable should not be repeated.

[benlsmith]

Your Name: Benjamin Smith

Overview of Lab Comments: This lab was very well structured and informative but it was a bit long for just introducing these topics to students in just 2 hours. It took me a bit longer than i would have liked, so I don't think that all of the students will be able to finish this on time. Maybe having another lab in the future with one less project work day would be beneficial to split the last 2 labs into 3. Also, with the material presented it may be beneficial to encourage note taking of the slides, or condensing most of the newly introduced concepts into a summary page at the end of the lab.

[william0cheung]

William Cheung

Overview: Good lab introducing lists and data structures in Python: it is great to be able to show the comparisons to Snap! language. The exercises are great practice, though some might be more difficult at first, especially with the HOFs: the syntax might be really strange to the students, and they might need more time just translating what they are thinking into Python code. Maybe adding some starter/skeleton code could be helpful to get them off the ground. I LOVE the dictionary description, though it comes at the very end where students might not get to the first time they try this lab, or they will attempt to get checked off before reaching dictionaries. In any case, this is an awesome lab!

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_mutability.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Concept Clarity Severity: Minor Comments: When saying "In Python, when a list is "copied" to another variable, the list is not actually replicated, both variables now simply point to the same list," maybe elaborate on what the pointer actually does.

Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/python_iterators.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Concept Clarity Severity: Minor Comments: I like the introduction to Iterables and Iterators but it might be glossed over quickly. These are important concepts, especially dealing with data, so I suggest more information and maybe examples of what an Iterable is compared to an Iterator.

[jesslarson]

Your Name: Jessica Larson

Overview of Lab Comments: I liked this lab, but there were far too many pages where the student didn't need to do anything. It is easy to skip pages or miss the meaning of pages when there isn't an activity. There aren't many specific things I would change about this lab, but I would completely restructure it so that the material that needs to be read can be parsed in between actual activities, so the meaning is anchored in actual experience.

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

• [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/list_functions.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html       Type of Issue: missed opportunity       Severity: minor       Comments: It would be cool to mention that at the same time as "popping" the item of the list, you are also able to bind it to a variable.

[keehansullivan]

Your Name: Sean Sullivan

Overview of Lab Comments: This is probably the most python informative lab in this course, I really liked this lab because it helped me understand the thing which I found very weird about the Python coding language. This lab greatly prepared me for CS61a and I continue to use the skills I retrieved from this lab. Its quite long but definitely worth completing.

[thorsoch]

Your Name: Charles Thorson

Overview of Lab Comments: I really enjoyed the exercises in this lab. It really helps to sink in the basic concepts that will be vital for any programming one will do in Python. Although some of them are a bit tricky, and may take a while to figure out due to the new syntax, I think that the lab is feasible (maybe cutting down on the long explanation in the beginning and emphasizing the problems might be better though).