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

lmock commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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 commented 9 years ago

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

Stantlers commented 9 years ago

Your Name: Stanley Ho

Overview of Lab Comments: This lab is very helpful in teaching students how to use python by introducing important concepts of data structures in python. Personally, I refer to the page about HOF's to remind myself how to do it in cs61a.

seunghalee commented 9 years ago

Your Name: Seungha Lee

Overview of Lab Comments: This lab goes over a lot of important concepts of python. It has a lot of content and some of the exercises are quite challenging so students may need more than 2 hours to complete the lab. Also, I think it might be helpful to have a review page at the end of the lab that summarizes all the functions/concepts of the lab. It took a lot of time flipping between pages since every page had lengthy explanations when I wanted to go back to review previous material. Personally, I thought it was cool that they incorporated DNA sequences into the exercise. As a bio major, it made me see how python could be used in my area of study.

MaazUddin11 commented 9 years ago

Your Name: Maaz Uddin

Overview of Lab Comments: A very good and detailed lab. Each part of the lab was explained pretty well, and the exercises were challenging enough to test students, but not too easy that they zoomed through them. I think the lab is really helpful in terms of learning python, as data structures are used immensely in 61A.

There weren't really any issues that caught my eye. It was a very good lab, and one of my favorites.

msilva926 commented 9 years ago

Your Name: Melanie Silva

Overview of Lab Comments: Well done lab. Explanations are clear and full of great comparisons.

--- 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_iterators.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: clarificaiton Severity: minor inconvenience Comments: Maybe in the first image, have arrows that point to what the iterable and iterator are in the for loop.
[ ] 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: minor inconvenience" Comments: Point out that the HOF needs to be surrounded by brackets which returns a list
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/comparing_dicts_lists.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-data-struct.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: N/A Severity: N/A Comments: Great job on the dictionary/list image!!

janicechui commented 9 years ago

Your Name: Janice Chui

Overview of Lab Comments: The list mutation functions are clearly explained, but I feel that there could be more emphasis and clarity on the index of the lists in Python. As index 0 in Python corresponds with the first item of Snap which is Item 1. The aesthetics are nice and clear when explaining the differences between dictionaries and lists.

Laralinmcc commented 9 years ago

Lara McConnaughey Overview of Lab Comments: The lab is great at showing how snap lists can be translated to python. The lab does go over mutability in python in the beginning but towards the tail end of the lab it kind of drops it off. Maybe you can have some practice problems that say solve this problem twice once mutating the list and the second time creating a new list. They images are nice --- 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: i.e. lack of clarity Severity: i.e. "minor inconvenience" Comments: I think at the end when .pop() is introduced there should be a note that when .pop() is called with no arguments it just removes and returns the last item of the list.
[ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/comparing_dicts_lists.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: Should mention somewhere here that dictionaries like lists are mutable

Rshahatit commented 9 years ago

Your Name: Rami Shahatit

Overview of Lab Comments: I really like the Snap! next to Python pictures. They really help me see and transfer my Snap! knowledge and apply it to python. I used to go back to this page and look at how certain functions are defined in snap that are also defined in python. I liked this lab and it had a positive effect on me when i went into cs61a. It gets the students interested in continuing which i think is important. --- For each specific Issue (Copy this section as many times as necessary) ---

[ ] Page Link: Type of Issue: lack of clarity Severity: "minor inconvenience" Comments: The wording of this sentence is confusing. Maybe reword it.
[ ] 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:lack of clarity Severity: "minor inconvenience" Comments: I would find it helpful to include some description of dot notation

chnicoloso commented 9 years ago

Your Name: Christian Lista-Nicoloso

Overview of lab comments: This is a good lab. I think a lot of parts are extra challenging, like the banditos section but I remember really liking this lab when I did it last semester. I love the graphics in the python labs, they are very nice. I don't have much more to say except for the few issues that I found.

The following issues are in the starter file itself: -In the substitute_base function exercise, the doctest given to the student has an error: It says that:

    >>> substitute_base("AAGTTAGTCA", "A", "C") # substitute "A" with "C"

should return "CCGTTCGTCG"
but really it should return "CCGTTCGTCC"

-In the find_players function excercise, there are a couple errors in the doctest given to students:

    1) >>> turing = {"age": 41, "height": 70 "weight": 160, "instrument": "theremin"}

    There should be a comma separating the value of the key "hight" and the key "instrument".       Like this:
       >>> turing = {"age": 41, "height": 70, "weight": 160, "instrument": "theremin"}

    2) In the "alonzo" variable name, the key for the instument is called "instrument " with a space between the "t" and the quotation mark.

    3) When setting the "banditos" variable name, we asign each key a value that stores another dictionary, like this:

        >>> alonzo = {"age": 10, "height": 42, "weight": 175, "instrument ": "fiddle" }
        >>> turing = {"age": 41, "height": 70, "weight": 160, "instrument": "theremin"}
        >>> bertha = {"age": 32, "height": 97, "weight": 587, "instrument": "cello"}
        >>> tinkerB = {"age":100, "height": 4, "weight": 0.5, "instrument": "cello"}
        >>> banditos = {"Alonzo": Alonzo, "Turing": Turing, "Bertha": Bertha, "TinkerB": TinkerB}

    However, this doesn't work because we created names without capital letters but are trying to use names with capital letters.
    It should be:

        >>> alonzo = {"age": 10, "height": 42, "weight": 175, "instrument": "fiddle" }
        >>> turing = {"age": 41, "height": 70, "weight": 160, "instrument": "theremin"}
        >>> bertha = {"age": 32, "height": 97, "weight": 587, "instrument": "cello"}
        >>> tinkerB = {"age":100, "height": 4, "weight": 0.5, "instrument": "cello"}
        >>> banditos = {"Alonzo": alonzo, "Turing": turing, "Bertha": bertha, "TinkerB": tinkerB}

    4) The very definition of the function find_players is wrong because it misspelled one of the arguments. It says "insturment" instead of "instrument"

robrodz commented 9 years ago

Your Name: Robert Rodriguez

Overview of Lab Comments: I think the snap-python pictures are extremely useful and beneficial to understanding what something means in python in relation to snap. However, I also think this lab is a big leap in difficulty compared to the previous python lab. I think there needs to be a more gradual progression in difficulty.

mfujimoto commented 9 years ago

Your Name: Mason Fujimoto

Overview of Lab Comments: I feel this is a great lab. I enjoyed how interspersed with pictures it was and I believe that these pictures will help students realize that they know how to do every exercise in this lab on the conceptual level (insofar as they can do it in snap). I am concerned that the length is too much. I feel like having just switched to python students will be having a lot of questions related to syntax and terminals and cannot simply breeze through this lab. I feel this lab will not be completed in one period which I think is generally undesirable (insofar as if a few sequential labs take more than one period, students will fall behind and be unable to finish labs when help is available).

I don't know where one would fit this in the lab, but I feel that the online python tutor (http://www.pythontutor.com/visualize.html#mode=edit) used in CS61A may be helpful for some students. (if not used for students maybe it could be a tool for TAs and LAs).

nzoghb commented 9 years ago

Your Name: Nicolas Zoghb

Overview of Lab Comments: I found this to be a straightforward lab but, while everything is thoroughly explained, I couldn't help but feel underprepared. This was especially true when I got to the "flatten list" question. I couldn't think of how to start, let alone use iteration in combination with conditionals. I also feel like the pacing was a bit weird. Despite these issues, it was a good lab overall.

--- For each specific Issue ---

[ ] Page Link: (first few pages) Type of Issue: Pacing Severity: confusing/jarring to students Comments: The first few pages throw a lot of explanations and examples at the student while the later parts ask a lot of difficult questions. A solution to this might be combining the two more smoothly, allowing for a transition into a question which just has its concept explained. Alternatively, there could be reminders under each question reiterating what was taught on the previous pages (e.g. "hint: Python lists are mutable.")
[ ] 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 explanation Severity: student may not be able to grasp full concept Comments: Mutability is an important concept in Python data structures and it has to be made very clear. Maybe a box-and-pointer diagram to be included; explaining what it means for two different variables to pointing to the same list.

siyingwang commented 9 years ago

siying wang

Overview of Lab Comments: I think this is a great lab as it shows the comparison of python with SNAP which will help students a lot. I suggest to mention that "" is empty string, as what the students ask me often.

--- 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&course=cs10_sp15.html&novideo&noreading&noassignment Type of Issue: lack of clarity Severity: minor inconvenience Comments: give a hint of string is not mutable will be better for students to think

Meghna15 commented 9 years ago

Your Name: Meghna Dasgupta

Overview of Lab Comments: I think this lab introduces the students to the most important basic concepts in Python and I like that the Snap! and Python code are placed side by side as it really helped me visualize code in Snap! first when I was a student. I think this lab should be split into two different labs if possible because it first gives an overwhelming number of examples / information without asking the students to practice and problems and the exercises given towards the end of the lab are all pretty challenging for a student just introduced to Python. This could be one possible format for splitting it up:

First Lab: Introduce them to the different syntax and concepts and ask them to solve easy questions everytime a new lab is introduced.
Second Lab: Focus more on the exercises given at the end of the lab and have hints / small explanations to guide them through solving the problems.
- [ ] Page Link: http://inst.eecs.berkeley.edu/~cs10/labs/cur/programming/python/lists_intro.html?topic=berkeley_bjc%2Fpython%2Fbesides-blocks-datastruct.topic&novideo&noreading&noassingment&course=cs10_sp15.html Type of Issue: Lack of Clarity Severity: i.e. Minor Comments: At the bottom of the page, where the example of names[1:3] is given I think it would be useful to iterate that it does not include the 3rd element as this is a confusing aspect which has not been discussed in Snap!
- [ ] Page Link: No specific page just during Lab Type of Issue: i.e. Error Messages when running tests Severity: i.e. Prevents students from continuing Comments: During the lab, the python terminal often gave error messages despite having completely correct code because the lines of code were not indented properly even though they looked like they were. This was extremely frustrating for students so I think it would be useful to talk about proper indentation use in the beginning of the lab to ensure that they do not get stuck on problems inspite of writing them correctly.

cs10 / bjc-r

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