Lab 10 - HackMD

--- tags: Labs-S23, 2023 title: Lab 10 --- # Lab 10: Understanding and Testing Mutation In this lab, we will continue with two ideas that we introduced in lecture: understanding how data mutation works and testing functions that mutate data. ## An Example of Sharing Data: Collaborative Editing When a program is maintaining data over time, sometimes we want that data to be shared across different parts of the program and sometimes we do not. Decisions about what should or should not be shared affect how we set up our data and write programs. ### Dataclasses, Examples, and Memory Diagrams Consider a tool (like Google Docs) that allows people to create documents and share them with other people. Here's a basic dataclass for Documents. ``` from datetime import datetime from dataclasses import dataclass @dataclass class Document: title: str last_edited: datetime contents: str hwk1 = Document("Homework 1", datetime(2023,1,31,13,24,36,10), "Write a program") # the parts of datetime are year, month, date, hours, mins, ... ``` When we call something like `Document("Homework 1", ...)`, we are using the `Document` *constructor* to create a new piece of `Document` data. :::spoiler **What is `datetime`?** [`datetime`](https://docs.python.org/3/library/datetime.html) is a Python library that provides support for working with dates and times. This comes in handy when you are, for example, trying to take the difference between two times. You can create a new `datetime` using the constructor `datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0)` (The `=0` means that those inputs are optional with a default value of 0). ::: <br> Another basic dataclass captures people who are allowed to edit documents: ``` @dataclass class Editor: name: str docs: list amaris = Editor("amaris", [hwk1]) ``` Imagine that the CS111 homeworks team is preparing assignments that are in different stages of readiness. Some documents are ready for sharing with others, but some stay private until the creators are ready to share them. **Task 1:** Copy the above code fragments to a Python file. Add variables and definitions to set up the following set of editors and documents with their corresponding sharing settings: - Katie as an editor with no documents - James as an editor who is also working on homework 1 (you should use the `hwk1` variable from the examples above as part of constructing the James `Editor`, just like the `amaris` example above) - Alex as an editor who is working on homework 2 (which is not yet shared with anyone)  Amaris has an inspiration for new ideas for homework 2. She doesn't want to disrupt Alex's progress, but she does want to try re-working content to see if her ideas make sense. The following tasks have you explore an approach that doesn't quite work, and an approach that *does* work. **Task 2:** As a warmup, put the following code in a new Python file. **Do not run it yet.** ``` x = 4 y = x y = y + 3 print(x) print(y) ``` With your partner, form a prediction of what the code should print out when you run it. Test your prediction by running the code, and come up with a short description of what you think is happening in the program directory based on the results.  **Task 3:** Add Alex's version of homework 2 to Amaris' list of documents. This should be done in one line of code, and reference a field from the Alex `Editor` (rather than constructing a new `Document`). :::spoiler How do I access a specific element of a list in Python? You can use the bracket notation to get an element. Just like Pyret, Python starts counting from 0: ``` my_list = ["hello", "there", "friend!"] print(my_list[1]) # prints "there" ``` ::: <br> **Task 4:** Make a change to Amaris's copy of homework 2 by adding a sentence onto the contents. Print out the contents of Amaris's copy of homework 2 and the contents of Alex's copy of homework 2 by accessing the fields in those pieces of data. With your partner, discuss what do you notice. How is this different from the results in Task 2? How does your current understanding of the program directory change based on these observations? :::spoiler Expand for more information after discussing In class, we saw that changes made by a function can persist for specific types of data (lists and dictionaries). This is also true of dataclasses. In fact, something deeper is happening here -- aside from the program directory, which keeps track of the values of "primitive" types (ints, floats, strings, bools), Python also keeps track of a "program memory." In class on Friday and Monday, we will get a more detailed view of program memory and see many examples of what consequences this has on data. ::: <br> **Task 5:** Revise your code for task 3 to add a distinct copy of homework 2 to the Amaris `Editor`. You can create a new copy of a dataclass in memory by using its constructor. How can you call the `Document` constructor such that it copies the contents of Alex's homework 2? Repeat task 4 with this new code, and make sure that the contents for Alex's and Amaris' homework 2s are now different. Amaris and James have been working on homework 1, but their idea isn't working out. It's such a mess that they have decided to just throw away their old attempt and start over. **Task 6:** Here are two ways to "start over" on homework 1. At the end of all of your code (after the Amaris and James `Editors` were constructed), separately try each of the approaches. Print the contents of Amaris's homework 1. What do notice? *To check that you've done this task as intended, the results should be different for each approach.* ``` # Approach #1 hwk1 = Document("Homework 1", datetime.now(), "This is much better") #Approach #2 hwk1.last_edited = datetime.now() hwk1.contents = "" ``` One of the most subtle concepts to internalize when starting to work with updating data is the difference between updating **variables** and updating **contents of data structures**. The previous task highlights the differences. **Task 7:** To help you internalize these details, please talk through the following questions with your partner. 1. If we update what `hwk1` refers to using approach 1, which editors will see the changes? (Choose one) - Anyone that already had access to the old hwk1 - Anyone that gets access to hwk1 in the future - Both past and future editors of hwk1 2. If we update what `hwk1` refers to using approach 1, will there be any way to access the original `hwk1` contents? 3. If we update the contents of hwk1 using approach 2, which editors will see the changes? (Choose one) - Anyone that already had access to the old hwk1 - Anyone that gets access to hwk1 in the future - Both past and future editors of hwk1 4. If we update what `hwk1` refers to using approach 2, will there be any way to access the original `hwk1` contents? It's ok if you still have questions about updating variables and updating contents. Put any questions you have in [this form](https://docs.google.com/forms/d/e/1FAIpQLSd5hCL1IukhzsJDJU2wyQe-ySF83QlOw1XMzaJNQAUCokB16A/viewform?usp=sf_link), which Milda will look at before class on Friday and Monday. --- ### *CHECKPOINT:* Call over a TA once you reach this point. --- ### Functions for Key Document Tasks Creating, sharing, editing, and copying documents happen so often that it would make sense to have functions corresponding to those tasks. **Task 8:** Write a function `create` that takes an `Editor` and a document title. The function creates a new document, stores it in the editor's list of docs, then returns the new document. **Task 9:** Write a function `edit` that takes a Document and a string (for the new content) and replaces the document contents with the new text. **Task 10:** Write a function `share` that takes a `Document` and an `Editor` and adds the document to the editor's list of docs. **Task 11:** Write a function `copy` that takes a document and returns a copy of the document. The copy has the same title and contents as the original, but the `last_edited` component is the current date and time (use `datetime.now()` to get this). **Task 12:** Look back at your four functions: which ones return something and which ones don't? Focus on the ones that don't return anything. Do they "accomplish" anything? Can you articulate what a function that doesn't return anything has to "do" in order to be of use? Write down your answer. (*hint: think about our `append_8` example from lecture*) ___ ### *CHECKPOINT:* Call over a TA once you reach this point. ___ ### Testing Now, we have to figure out whether the functions you've written provide the sharing conditions that we had in mind. In particular, think about the `edit`, `share`, and `copy` functions. Your goal is to fill in this template of a testing function: ```=python def test_docs(): "SETUP" # your scenario setup goes here "PERFORM MODIFICATIONS" # calls to your functions go here "CHECK EFFECTS" # assertions go here ``` **Task 13:** Identify an initial scenario of editors and documents against which you will run your tests. Create the corresponding data in the "SETUP" area of `test_docs`. **Task 14:** Write down (in prose) a list of effects that these operations **should** have. Put these in a multi-line string comment above your `test_docs` function in your file: ```=python """ Expected effects: - If we create a doc titled t for an editor, the editor will have a document with title t in their docs list - YOU ADD MORE ITEMS HERE """ ``` **Task 15:** Write down a list of effects that these operations should **not** have. For example, "if one document is edited, then the contents of another document should not change". Add these in a separate comment like the one above in your file. **Task 16:** Make a collection of calls to the `edit`, `share`, and `copy` functions in the "PERFORM MODIFICATIONS" section. These calls should be sufficient to perform the checks that you outlined in your lists of effects. **Task 17:** Turn your expected and unexpected effects into pytest assertions, putting those in the "CHECK EFFECTS" section of the testing function. **Task 18:** We are curious to see which effects groups are and aren't identifying. Please visit this [Google Form](https://docs.google.com/forms/d/e/1FAIpQLSd5hCL1IukhzsJDJU2wyQe-ySF83QlOw1XMzaJNQAUCokB16A/viewform?usp=sf_link), and copy/paste your prose lists of expected effects. ___ ### *CHECKPOINT:* Call over a TA once you reach this point. ___ ### Global variables In a large course staff like we have for 111, having a separate variable for each TA/Prof makes our code a bit hard to manage. It therefore makes sense to make a list to hold all of the editors on our documents, as follows: ```=python all_staff = [Editor("milda", []), Editor("annabelle", []), Editor("cali", []) ...] ``` To help us keep track of all the documents we are working on, we want to make two additions to our current code: we want to be able to ask which staff have access to a particular document, and we want to maintain a count of how many documents we have. Let's start with the latter. We'll set up a new variable to maintain the count of documents that we have created. We'll also modify our `copy` function to update this count. **Task 19:** Create a global variable called `num_docs` and modify your `copy` code to increment `num_docs` whenever a document is copied. This code should not need a `global` keyword. **Task 20:** The following code computes a list of all staff who can access a specific document. ```=python def who_has(doc) -> list: "Produce list of editors with access to given doc" can_access = [] for editor in all_staff: if doc in editor.docs: can_access.append(editor) # return alternative 1 # return alternative 2 return can_access ``` The `who_has` function indents the `return` under the `for` loop. We could also have indented the `return` at the corresponding comments. Discuss with your partner what each return position would result in compared to the original `return` position. If you are finished with time to spare, feel free to take time to get ahead on the homework.  > Brown University CSCI 0111 (Spring 2023) > Do you have feedback? Fill out [this form](https://forms.gle/KCKEYu3JDw1WhCCr6). <iframe src="https://docs.google.com/forms/d/e/1FAIpQLSccr39t2Ogdns4h-Xm-UfZIEztrEo7PluyrrNFVSYPa3RPKaw/viewform?embedded=true" width="640" height="372" frameborder="0" marginheight="0" marginwidth="0">Loading…</iframe>