Alright, where to start? I got three weeks worth of work here. Apparently I’m supposed to grade 10 create performance task submissions and compare them to college board. I guess the following is below

Week number Submissions
Week 1 Submissions 1-2
Week 2 Submissions 3-6
Week 3 Submissions 7-10

The rubric is attached for reference. There are also some prompts to be aware of.

Alright, now I’ll start Week 1 I guess

Week 1 Work

Submission 1

Expect this to be a bit rough since this is my first one. I’m usually quite harsh, and I’m expecting College Board to be pretty lenient. Alright, let’s see what’s here.

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 0 Video appropriately shows program input of triangle side lengths and outputs of trig values in neat table. The written response includes the inputs and outputs, a certain functionality of the code through the output (trig table and side ratios). It is difficult to tell if program purpose is confused with program function, though it seems it is. 0 Pretty much the same as what I said. The video demonstrates input and output, and the response appropriately describes input, output, and program functionality (but not program purpose).
Data Abstraction 1 A list and its fulfilling of the programs purpose are clear. The list, however, is used to store potential outputs (namely the type of triangle), not inputs. The list is named appropriately. The data in the list is represented clearly. I’m going to assume using an output-storage list is not going to be a problem. 1 Includes two code segments, namely the data in the list and the data being accessed from the list. The list is named and the data is identified
Managing Complexity 1 A list is shown as managing output complexity. The student posits that without the list, the types of triangles will have to be put in the return statements, meaning the types of triangles supported are not all in one place. This solution seems to be plausible, as does the use of the list. The student notes that with a list, modification of code is easier since the types of triangles are found in one place. 0 Putting all the outputs in one place is not management of complexity, especially since the return statements is a simple replacement. We’re looking for something different here. Perhaps I have an idea. The student never showed the code behind the trig table scheme, and though each value shown requires but a simple calculation, there are 18 outputs to manage. A list could probably be used to manage complexity in this instance.
Procedural Abstraction 1 The code segments clearly show a student-developed procedure with three parameters (each are essential); the procedure is called soon after it is defined. The student identifies what the procedure does (outputs the ratio of the entered triangular sides) and connects the procedure to the program’s function, namely its output being required as part of the user-received output 1 The procedure is written and called, with three parameters. The functionality and contribution to the program is stated
Algorithm Implementation 0 The student makes a line-by-line explanation of what the algorithm does, though there is no explanation of the overall function of each portion of code (in other words, each line is explained separately). This may make it difficult to understand the function of certain portions of the algorithm until Question 3d is reached. There is sequencing, selection (two if statements), and iteration (depending on if the triangular sides can be simplified). Unfortunately, when explaining the for loop in the code, the student claims that the index will decrease from the maximum of previously defined constants (A, B, and C), when in reality it will decrease from the minimum of those constants (uses the python min(A, B, C) command). Therefore, I cannot award the point even if there was a solid line-by-line explanation, because the code described does not match the description. 1 Looks like College Board wasn’t paying attention and missed the error. Under normal AP grading conditions where administrators are given little time to grade hundreds of exams, this would be somewhat understandable. However, it’s a little surprising that the scores don’t get reviewed before they’re posted as examples on the official website.
Testing 1 This one is a bit difficult to work with. The student gives two different inputs and proceeds to state that the first conditional statement (which checks if the given integers are as simplified as possible) is checked for both of them. For the second call, the student also references the remainders conditional statement (in the for loop), which is executed since the first conditional statement failed to pass for the second call. The student is accurate to state that the first if statement is checked for both arguments, and technically part of the code is executed for both calls (that being the first conditional statement). I think I’ll let it slide since the way the algorithm treats the two inputs overall is different. 1 Two calls with different arguments are described, which result in different code segments being executed. The student identifies the output of each call.

Kind of messy as expected. I guess it’s time for Round 2.

Submission 2

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 1? Response 3ai nails the purpose (entertainment). The video demonstrates the ability of the user to use a mouse to draw starting tiles, which then behave according to Conway’s game of life. The output is in the form of the changing tile patterns on the screen. The video does not demonstrate the keyboard input (space, p, r), though this is specified in the written response. I’ll take mouse input as a sufficient showing of input in the video. 1 Pretty much the same as what I said
Data Abstraction 1 In blocky. Nice. OK, gotta look for that list. The student says there’s a startGrid, currentGrid, and nextGrid. This is an identification of the name of the lists, whose purpose (according to the written response) is to store the status of the 10800 cells on the screen using booleans (0 = dead; 1 = alive). The student says there are three lists to prevent overwriting issues as the program cycles through each generation. There are two code segments provided, and it is clear when the lists are being modified and how they are used to define program purpose. The definitions of the lists are not shown, probably since each list is 10800 elements long. However, the first procedure shows how the initial values of the elements in startGrid are set (through mouse input). 1 Similar to what I said, but only the first list startGrid is considered in scoring. Apparently College Board didn’t use the second program code segment since everything required (the list being used as part of fulfilling program purpose) was fulfilled in the first segment.
Managing Complexity 1 The student highlights the need to manage 10800 cells. Managing 10800 variables is impractical, so a list must be used. The procedure is able to change the elements of the list from 0 to 1 or vice versa. 1 Same as what I said
Procedural Abstraction 1 A procedure replaceList is defined in the first code segment and is called in other procedures. The procedure has two parameters which will be used to copy the contents of lists onto other list to save the grid positions. The student identified how the procedure will contribute to the functionality of the program. 1 In addition to what I said, College Board identified what the student said about the procedure contributing to functionality: it can store cells in a generation, copy them over to another list, and to recall previous generations.
Algorithm Implementation 0 There is sequencing, selection (many if statements), and iteration (where one list is copied to another list). The student gives a general overview about how the algorithm works. However, there is not a detailed, step-by-step explanation. 1 No need for a line-by-line explanation. It seems an explanation based on segments of the code is sufficient, which in this case described nested if-else statements identifying which list will be copied from, and then which list will be copied to.
Testing 1 Two call to replaceList are identified, one with parameters 0 and 1 (being current and replacement), and one with parameters 2 and 1. In both instances, the procedure checks the list being copied from, and the list being copied into. The results are identified (in the first call, the startGrid overrides the currentGrid; in the second call, the nextGrid overrides the currentGrid) 1 Pretty much the same, but College Board quoted the exact parts of the student response that met the criteria (as usual). The student elaborated on how the procedures would interact with the parameters.

Week 2 Work

Submission 3

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 0 The video demonstrates input on a screen that appears to be a gaming console, with buttons which appear to be activated on-click (it’s clear a web browser is open, after all). There are several animals on the screen, and the student uses an on-screen keyboard (which is arranged in alphabetical order) to type the names of the animals that appeared on the screen using the buttons. The letters typed appears as output, as well as whether the student was right or wrong upon submission. In the written response, the student confuses input and output, as well as program functionality and program purpose (though both are present in the response) 0 Same as what I said
Data Abstraction 0 There are two program code segments: one with the list animalImages with images of animals, and another segment with animalList but with the animal names in text form. For the sake of scoring, animalList will be considered. The code segments fail to show how the list fulfills the program’s purpose since only the list itself was provided, so the student already lost the point before the rest of the response. The student names the list animallist and claims the list contains both the animal names and the animal images, which is false. 0 College Board points out that the list is never used in the provided code.
Managing Complexity 0 The student claims the list allows for storage of more than one variable, and that without the list, defining more variables will be necessary and make the code longer. With the small scale of this project, making more variables is not necessarily harder than making the list. It is unclear if the list manages complexity in the program. 0 The College Board did not seem to accept the response about defining more variables.
Procedural Abstraction 0 The student has two program segments: one with the procedure evaluateGuess, and one segment where this procedure is called. The student describes what the procedure does (compare a user’s guess to the animals in the list and determine if it is correct). The student tries to state how the function contributes to the program, but this seems like a restatement of what the procedure does. 0 The College Board sees that the response is missing explanations about how the procedure contributes to overall functionality
Algorithm Implementation 0 There is sequencing, selection, and iteration in the procedure. The student’s explanation about how the procedure works is even more generalized than that of Submission 2, in that the student fails to reference the code (relying on a general explanation of how it works). 0 The biggest emphasis about describing the algorithm is that someone else can recreate it. There are many aspects of the algorithm the student did not explain, including the sound effects and the output text.
Testing 1 The student identifies two calls to the function dog and mouse, where the condition in each call is the same (if the inputted answer was one of the animals in the list). The outputs are different (the dog output was getting a point, whereas the mouse output was getting a strike), so the differing outputs may be sufficient for getting different code segments to execute. 1 Honestly there’s not too much to say about this. The student identified two arguments, the conditions checked, and the differing outputs…

Submission 4

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 1 In the video, the student inputs words via keyboard in accordance with provided prompts. The student then sets a few presets regarding the poems that will be outputted, including how many poems there will be and if any articles will be included. The terminal outputs randomly-generated poems that consist of the inputted words. The response provides some program purpose (exploring creativity through expression of poetry) and elaborates on the function (poem generation) using the inputs of words (which output poems) 1 The video demonstrates input, output, and functionality, as does the written response. The written response also elaborates on program purpose
Data Abstraction 1 The code segments include a defined list (with the stored data of user input). That list is then utilized in a procedure (where it is renamed due to parameter conventions). The list is named nounList (called wordList as a parameter of the procedure selectWord). The student identifies what data is in the list (nouns) 1 Same as I said. Changing the name of the list when passing it as a parameter is of importance.
Managing Complexity 1??? The student manages the complexity of random generation of nouns. In Response 3biv, the student mentions the nouns must be in specific locations in the poem. This implies nouns must be randomly generated independently of other word types. The student posits that without a list, a difficult random variable selection scheme must be implemented consisting of if statements with conditions controlled by randomly generated integers (one if statement for each integer). The solution without the list is impractical, and the response points this out. 1 In addition to managing complexity, the hypothetical response to not using a list is taken seriously.
Procedural Abstraction 1 There is a student-developed procedure createPoems with 4 parameters nList, vList, aList, and aSetting. This procedure is called during the output section of the code. The student identifies the contribution to the program’s function as compiling the poems based on the number requested and if the student requested articles. The student is able to describe what the procedure does:0 it makes a variable to count number of poems generated, makes an empty string, and uses conditional statements to generate poems with or without articles 1 The response has the procedure with 4 parameters, and it contribute to the overall function since it uses input
Algorithm Implementation 0 A weakness in the student’s response is that the procedure createPoems depends on the procedures articlePoem and noArticlePoem, which are not defined within the given code segments. As such, replicating the code is impossible, and any replication attempts will likely be significantly different compared to the original code. 1 The response explaining how the segment works was fairly detailed. It appears creating the procedures called within a procedure is not required in recreating the algorithm, which is a bit strange. This might have something to do with limited response space. I guess I’ll take it.
Testing 1 The student identifies two calls with different arguments; one call with articles and one call without articles. The student says the same conditional statement is checked (the one from response 3ci, which checks the aSetting), but different conditions passing cause different outputs. The first call will result in a poem output with articles, whereas the second call will result in a poem output without articles. The written response references line numbers that are missing in the code segment submissions. This may cause scoring discrepancies. Pretty much the same as what I said  

Submission 5

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 0 The video shows some user input with buttons. The user interacts with drop-downs to pick two characters, and then click a button to see a winner. There is the output of the winner as well as the stats of each character. The written response appropriately identifies input, output, program function, but program purpose seems to be mistaken for program function. 0 I’m kind of running out of things to say here. The student said the program purpose was to find the winner in a fight between two Marvel characters, but this is clearly the function.
Data Abstraction 1 JavaScript in blocky. Seems like someone used code.org. Regardless, there seems to be a list firstCharacterList, which seems to be overwritten by data from a pre-existing list characterPowers each time the user selects a new character. The written response identifies the list and where it is used (as a parameter in a procedure; the student doesn’t specify that the parameter name needs to be different from the list name). The response also identifies the data in the list (the stats of each character and the URL of an image) 1 Yeah. I guess this establishes that students don’t have to show the College Board the data to establish how data is stored in a list. Yeah, the grading is pretty lenient.
Managing Complexity 1 The students states that using a list allows for condensing the amount of variables required to be defined, and also prevents the function from requiring too many parameters. The student states that if there wasn’t a list, a variable would need to be defined in place of each element of a list and the function would have many more parameters. In addition, the variables would have to be added to get the average score for each character. Using lists greatly simplifies the process. 1 Yep, reducing the number of parameters is managing complexity.
Procedural Abstraction 1 The procedure has two parameters, which are two lists (each corresponding to the two characters), and the second code segment has the procedure called when the student clicks the Winner_Button. The student is able to identify what the procedure does (compares the average statistics of the two characters and changing the winner screen to depict the character with the higher average), or a tie if applicable. The student says this contributes to program function by determining the winner in a battle between the two characters (notice the overall context added here). 1 Yep, I guess just a tip about telling if a student talked about the procedure adding functionality to the program is stating what it does in context…
Algorithm Implementation 1 The algorithm contains sequencing (lines to execute), iteration (a for loop used to add the sum of the character’s statistics by summing the relevant elements of each character’s corresponding lists), and selection (if statements which modify the winner screen based on which character has the higher average). The student makes a line-by-line explanation about how the procedure works, which may allow someone else to replicate the procedure if the data in the lists were given 1 College Board just copy-pasted the student’s response here. I guess they consider the procedure independently of everything else and intentionally overlook any dependencies (ex: list data, other procedures) which the developer might have to give to someone else before replication is possible. That’s probably due to space limitations in the response, which in turn is due to time limitations the AP admins have to grade all these responses.
Testing 1 The student gives tests for two parameters: one call with Vision as the first character and Bishop as the second character, and the second call with Carnage as the first character and Venom as the second character. The student specifies the part of the conditional statement in the procedure that will be tested; for the first call, the first part (where the first character has a greater average stat) is executed, whereas for the second call, the third part of the conditional (associated with a tie) is executed. The appropriate outputs are then stated (a winner screen with Vision for the first call, and the tie screen for the second call) 1 Running out of things to say here. College Board pretty much says what I said about this point. I guess the only thing I really have to say is that they’re not too picky about grammar (but I’ll still make sure my responses are polished).

This is starting to get a bit smoother now.

Submission 6

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 1 The video shows a game OCTORDLE where the student tries to guess the 8-letter word. Clicking on the turtle starts the game, where the student gets 6 guesses to type (input) the 8 letter word. After each attempt, the program outputs the word with highlighted letters; the green highlights are correct, while yellow highlighted letters are present in the word but misplaced (the words have unique letters). Red highlighted letters are not present in the word. If the student guesses correctly within 6 tries, there’s a win (otherwise it’s a loss). The written response has a program purpose of critical thinking skills. Nice. The student talks about the inputs of clicking the help button (for a guide) or a turtle (to start a game), as well as typing inputs for each guess. The output was each word with the colored highlights and a win/lose screen at the end of each game. The student then started to describe the sequence of events in the video (which I believe is not what students are supposed to do), so program functionality may not be explicitly stated. Grading this one may be tricky due to the unexpected response. I’ll just lift something directly off of College Board to help. “The function is the behavior of a program during execution and is often described by how a user interacts with it.” I guess describing the events of the video passes for program functionality since a user interacted with the program during the video. 1 Yeah, stating what happened in the video is a workable answer, especially since College Board is asking you to do the same thing twice (demonstrate inputs, outputs, and program functionality)
Data Abstraction 1 The student identifies the list as guesses, which according to the first code segment is cleared when the game starts. Each answer is appended into guesses as they are inputted, and in the second program segment, it seems the length of the list is used as an index to check when the maximum number of incorrect guesses is exhausted (lose condition). The student says the data in the list represents all the user’s word inputs. It seems this list fulfills all criteria for Row 2, but how it is used has ramifications for Row 3. 0 Apparently the data in a list has to be accessed, so indexing lists don’t fulfill the criteria.
Managing Complexity 0 The student states that without the list, each guess would have to be stored in a separate variable and that the 6 guess limit would fail to be enforced. However, it is easy to set an index variable that increases by 1 on each guess, meaning that there is an alternative which is actually easier to implement (since the index variable doesn’t store all the responses). It doesn’t seem like the responses stored in the list are utilized in any manner. 0 Index variables don’t manage complexity. The student also refers to a nonexistent list.
Procedural Abstraction 0????? There are two code segments, one with the procedure isiscorrect? and one code segment where this procedure is called. The student describes its overall contribution to program functionality as a checker (if the correct word/letter positions are in each guess). It is difficult to tell if the point is met here, especially since it seems only the first sentence in 3.c.iii is relevant to the question. 1 Apparently, saying the algorithm is needed every time a user makes a guess is talking about the algorithm’s contribution to the program, perhaps by establishing its significance. I thought that statement was irrelevant at first, probably since I was used to ignoring statements like those on essays. This is different. I’ll be on the lookout for statements that establish significance in the future.
Algorithm Implementation 0 There is appropriate sequencing (block of code), selection (when determining how color to highlight a word), and iteration (where each letter of a word is checked and highlighted). There are some issues with the explanation, namely that it claims that there is no output if there is an input of less than 9 letters (but if the input is 8 letters, the program apparently functions normally). It seems more accurate to say that the algorithm will not have output for inputs of at least 9 letters and accept any input less than 9 letters. Regardless, the explanation goes on to talk about the conditional statements assigning letter highlights and about how this is iterated for each of the 8 letters. It then talks about changing the screen upon winning or losing, and mentions running out of guesses. The number of guesses (6) is not mentioned in the description, which may cause deviation if someone made a full-blown knockoff of the official game (13 guesses). I could be picking on trivial matters. 1 I guess College Board failed to pay attention again. The conditional statement is certainly different from how it is described in the written response. The written response claims the statement will reject inputs less than 9 letters, when in reality it will reject inputs of at least 9 letters.
Testing 0 This one is hard, namely because specific arguments are not given (rather, highly generalized arguments are given). The student has a call with a right letter in the right position and a second call with the right letter in the wrong position. Upon reviewing the call from 3c, it seems these aren’t actually calls since the correct form of argument is an entire 8-letter word. As such, even though different parts of the procedure are executed for each letter and the result of each execution on the letter highlighting differs (green in the first instance, yellow in the second instance), the student does not get a point in this row. 0 Yeah, College Board also noticed that these weren’t arguments. They did consider the other points separately, however.

I wanted to find this program and test what happens when you input a word less than 8 letters long, and I found it here. I inputted the word break, and it seems that if the word runs out of letters then it just fills in the last space with copies of the last letter. There’s a few other quirks:

Week 3 Work

Submission 7

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 1 The video shows the student inputting keyboard commands into a terminal, which outputs a rock-paper-scissors prompt. If the student doesn’t take an option, the prompt is re-used until the student picks an option. The computer then chooses and option and may win, lose, or draw, after which a prompt allows the student to play again. In the written response, the student says the program was for entertainment and decision making. The user describes the function as the user picking rock, paper, or scissors, and the computer picking one. It’s a classic. The inputs are types as Rock, Paper, or Scissors, while the outputs are the results (win/lose/draw) 1 Not much else to say here. This may seem obvious, but printing text to the terminal is a form of output.
Data Abstraction 0 A list called RPS is made (shown in code segment 1). The second code segment compares the variable yourPlay (implied to be user input) with cpuPlay (computer’s choice). The written response says the list RPS contains the three options which the computer can randomly select; unfortunately, the code segments don’t show a random element in the list being defined as cpuPlay, so this doesn’t get the point. 0 Yep, second code segment doesn’t show data being accessed from the list, even though it actually is in the program. The lesson here is to remember to upload the right segments of code.
Managing Complexity 0 The code segments fail to show how the list is being used to manage complexity since it fails to show how it is used to assign a random element to cpuPlay. In addition, the proposed alternative, where the computer randomly generates a number between 1 and 4 exclusive (where the numbers become placeholders for each rock-paper-scissors option) can only result in 2 integers (2 and 3), so the simulation of rock-paper-scissors with this alternative fails. 0 In terms of managing complexity, randomly picking elements from a list doesn’t count.
Procedural Abstraction 0 The first code segment includes the procedure rpsGame with parameter yourPlay. Sure enough, there is the randomization of the cpuPlay variable that was needed for the point in Rows 2 and 3. The second code segment demonstrates the procedure being called. The student describes what the procedure does (namely saving user input, which passes through a series of conditional statements resulting in output based on the user input and computer input). The closest statement found about how the procedure contributes to the overall program functionality is that it “allows for the program to execute smoothly.” I don’t know if this works. Probably not. 0 Yeah, that doesn’t work. Probably needs to imply something along the lines of the function being called many times. If the function is just called once, why did you define it?
Algorithm Implementation 0 The program has plenty of sequencing and many conditional statements. No iteration in the form of for loops, however. The student describes the first parts of the programs clear enough, but is a bit vague when talking about all the conditional statements. Perhaps mentioning that they behave in a similar manner to rock-paper-scissors would have been sufficient. 1 Pay attention to recursive functions (which is essentially the entire procedure). The student can play the game again by responding yes, which essentially calls the function within itself.
Testing 1 The student identifies two calls to the procedure: one where the argument was “Rock,” (with the computer choosing “Paper”) and a second call with argument “Paper” (with the computer choosing “Rock”). The student identified that a different conditional statement was satisfied and executed in each case. For call 1, there was a lose output, whereas for call 2, there was a win output. 1 A bit of a disclaimer, the computer’s choice is not an argument in the function. Honestly should be careful not to make a procedure where a randomly generated value becomes just as important as arguments inputted into the system.

Submission 8

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 1 A code.org video project. Hangman. There’s lots of mouse input and clicking buttons. There’s also a space where the student types letters. The output comes either with the letter appearing on the screen or the lives decreasing by one. The student shows it’s possible to input special characters and more than one letter, but this will always lose a life. The written response says the program has a purpose of building vocabulary. In practice, this statement likely applies only to young children since the game supports 5-letter words. The response also demonstrates program functionality (where the user can input letters, and the program either outputs the letter or takes a life). The response demonstrates keyboard input for the letters and an output of a letter where it belongs in the word or the win/lose screen. 1 Yeah, program purpose can be pretty much anything here, no matter how qualified it might be.
Data Abstraction 1 This one’s interesting. The student identifies the list as letOfGuessWord, which stores the letters that the users will guess. The first code segment seems to configure for the lives and the word used. A pre-existing list allWords is filtered for 5-letter words, which are appended to words5. A random 5-letter word (element) is selected, and each letter becomes an element in letOfGuessWord. This shows how data is stored. This data is utilized in a for loop which seems to check if the input (stored in letter) is the same as any of the letters. This shows how the data in the list is used to fulfill program purpose. 1 I don’t really have anything to say here. College Board said the same thing I said.
Managing Complexity 1? The list in the program code segment is clearly used to manage complexity by splitting each of the 5-letter words into component letters (hangman players guess one letter at a time). The written response says that without a list, each letter would have to be stored in a separate variable and the variables will have to be looped through to check if the inputted letter matches a letter in the word. As far as I can see, This would cause repetition of commands, which proves that the list makes the program easier to maintain. 1 One part of managing complexity is scalability. If a word longer than 5 letters was ever implemented, the list would support longer words.
Procedural Abstraction 0? There is a program code segment with the procedure guessWords with a parameter of letter. The procedure is called in the second code segment upon detecting a change of the value inside the input box. The written response says the function compares the letters of the random word to the inputted letter; if correct, the letter appears where it belongs, whereas if incorrect, the user loses a life. The closest response to how the procedure contributes to program functionality is that it “does most of the work.” This is difficult, since this statement does seem to establish a degree of significance but doesn’t imply the procedure is run repeatedly throughout a game or talk about how it contributes to program functionality. 1 This part gets a bit confusing. I guess the first sentence establishes appropriate context.
Algorithm Implementation 1 There is sequencing in the lines of code; selection through if statements checking for a correct guess, an incorrect guess, a win condition, and a lose condition; and iteration in a for loop as the inputted letter is compared to each letter in the base word. The user describes setting the variable lives to 6; however, this happens outside of the procedure. The description is pretty detailed, though returning the check variable only occurs during a win condition. 1 Yep, this explanation is pretty detailed. I guess College Board doesn’t like looking for discrepancies, even if the scoring guidelines tells them to.
Testing 0 This one’s weird. The student has calls with two arguments: one with 1 and one with h. In both cases, the student says the conditional statement tested was the if statement within the for loop, which compares the argument to all the letters within the word “hello” (the word generated by the computer). The student says the result of the first call is false since 1 is not in hello, whereas the result of the second call is true. However, these are not the output results (the result of the first call is losing a life; the result of the second call is the h being displayed in the first spot) 1 A result does not need to consist of output. It seems something as simple as changing a variable could be identified as a result

Submission 9

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 1 The video shows user input in the form of interaction with a dropdown menu to see information about states in the U.S. The output comes in the form of state information, which includes population, area, and the capital city. Other information also becomes available via further mouse input. The written response says the program’s purpose is to help users learn information about the U.S. states, which could be used to memorize information. Function is identified as the user selecting a state and seeing a screen with information about the state. Input is identified as the selected state or extra forms of information (both from drop downs), while output is implicitly stated to be the corresponding information being displayed on the screen. 1 Yeah, this is about the only response the student did right.
Data Abstraction 0???? The student identifies the list as stateList, and says the data in the list represents the state information the user will see on the information screens. In other words, this is all of the possible output text/images. The first code segment does not contain the list, whereas the second code segment shows a function where the length of the stateList is used as an index and seems to store the names of all of the states. Other lists are used to store the other forms of information. It seems the code segments were given in reverse order, and the contents of stateList are copied to list stateName, which is utilized in the first code segment to output information. There are other lists used in the first code segment, which makes the student’s claim (the list contains all of the information) inaccurate (since the list only contains state names) This is difficult to score because the code is formatted in an unexpected manner. 0 Yep, accurate descriptions about the data in the list is required. Also, a copied version of the list being used doesn’t count.
Managing Complexity 0 The student states that without the list, “all the data would have to be coded independently.” It is unknown what this statement means, though the closest guess would be that hundreds of variables would have to be defined for each piece of information. 0 Yeah, the fact that I had to make assumptions shows that the student’s response was too general.
Procedural Abstraction 0 The student-developed procedure updateScreen doesn’t have any explicit parameters, and it is not called in the second program code segment. The procedure is described as having a function of receiving the state input from the user and updating the screen with the correct information. It doesn’t seem to do the latter. 0 Also remember about the procedure contributing to program functionality (was absent in this response)
Algorithm Implementation 0 The segment has a lot of sequencing and selection in the form of 52 conditional statements. Apparently the student can’t do iteration. The student points out the inefficiency of using 52 conditional statements while explaining how the algorithm works, but the description is detailed enough that someone might be able to recreate it. 0 The user description is missing how the indexing system works, so there’s a lack of detail
Testing 0 The student identifies the function as stateInput, which actually seems to be a list. Regardless, the student says there’s a call to update the screen and a call for more information. This doesn’t seem to apply to the procedure in 3c, so this loses the point. The student’s conditions tested seem to mirror calls more closely than conditions, though the results seem to be correctly identified. 0 Output is not equal to the result of a procedure. I’ll have to learn that.

Submission 10

Reporting Category Student Score Student Comments College Board Score Comments about College Board’s Score
Program Purpose and Function 0 The written response identifies the purpose as entertainment (it’s a game, after all). The described functions include the movement of the boat, the fish hook, and a score function, which keep track of the number of each type of fish caught. Described inputs are the a and d keys (output: the boat moves left/right) and the space (output: hook moves down). There is also the output of the total fish caught and the points earned at the end of the game. The video demonstrates the outputs of the boat’s movement and the fishhook, as well as the fish and points output at the end. It is impossible to distinguish keyboard inputs in the video. 1 Evidence of input (which is essentially output) satisfies this criteria, even if it is impossible to know what that input is.
Data Abstraction 1 The list is identified as fishtypes, and is claimed to have the data of the amount of each type of fish that is caught. The second code segment shows this data being utilized as part of the code which outputs the number of each type of fish at the end of each game. From that code segment, it seems this list is actually similar to a python dictionary, in that each element stores both the type of fish (small/big/grand) and the number of that type of fish caught. The first code segment appears to show the functionality of increasing the number of fish caught for an element by 1 when a fish of that type is caught. This seems to pass. 1 Nothing much to say here, other than perhaps that naming conventions don’t matter here
Managing Complexity 1 The list appears to appropriately manage program complexity by allowing for the use of a for loop (rather than writing out the same command 3 times with three different variables). The student says that without the list, multiple variables would be required for the type of fish and their amounts, which would lengthen the program. The student also points out that the list is more scalable (more practical for larger amounts of data) than this approach. This seems to pass. 1 Referencing scalability is probably one of the better ways to respond to this question, especially since College Board quoted it.
Procedural Abstraction 1 The first code segment shows a student developed procedure clone movement (in blocky) with 5 parameters (two y-parameters, two x-parameters, and a return state parameter). The procedure is called for generating the various fish in the program. The student says the procedure determines where each fish appears and how far it can move. The student says this contributes to program functionality by making the game more challenging since the procedure randomizes fish speed and height. This may pass. 1 Running out of things to say here. I guess naming discrepancies in blocky don’t matter too much; College Board saw a function clone+movement+range whereas the student saw a function clone movement
Algorithm Implementation 1 There is a program code segment with sequencing (lines of code), selection (which configures what happens when the fish is touching the hook), and iteration (which results in the conditional statement being checked until the fish is caught or the game is over). The explanation says the procedure begins by randomizing the starting position of a new fish. The student then describes the conditions that the loop will stop executing before describing the loop. The student then describes what happens inside the loop: a condition is tested, namely that the fish has reached the right side of the screen. If so, the fish is teleported to the left of the screen with a random height. If not, the fish moves a random distance. This seems sufficiently detailed. 1 Yeah… College Board said the same thing I said.
Testing 0 The calls identified are actually executions of part of the procedure, rather than calls to the whole procedure. Regardless, the condition tested (if the sprite touches the right side of the screen) is accurate, as are the results. 0 The conditions tested have to correspond to the parameters/call of the procedure. Also, the code is not the result.