Ant11234
commented
8 months ago Grader: Anthony Bazhenov
Crossover Grading for FRQ and Association
FRQs
| Title | Grading Description | Score |
|---|---|---|
| FRQ 1 | FRQ is fully completed with all parts working with outputs. First talking about the type of question it is and what completing an array/ array-list question entails, and the things you need to know in order to be able to complete the frq. This shows a deep understanding of the FRQ and array/ array lists. Additionally, you talk about your thought process coming into the FRQs, and how you solved each one. The reflection is also well written and talks about the difficulties faced while completing this question, and you added how you overcame the problems you were struggling with, like 2D Arrays. | 1.0 |
| FRQ 2 | The FRQ is fully completed with the hidden word game giving correct hints based on the rules of the game and the word provided. The explanation of how the FRQ was solved is detailed showing all the steps taken in order to get the game to work showing a deep understanding of the FRQ. Finally, the reflection contains new learning from the FRQ showing improvement and growth from the FRQ | 0.98 |
| FRQ 3 | FRQ contains all parts fully completed with functioning outputs based on what you would expect to see. The type of FRQ is said in the beginning, and there are detailed steps for each part of the FRQ explaining the steps taken to solve them. Reflection goes over the difficulties faced while doing this question, and how she managed to overcome them to complete the FRQ. | 0.97 |
| FRQ 4 | All parts of the FRQ are completed with working outputs. Has detailed comments throughout the code explaining what each section does, and goes through step by step on how she solved all three parts. Reflection is detailed explaining the difficulties she faced, saying that this was one of the hardest FRQs out of the 4 due to the newer topics needed in order to complete this FRQ. Despite this she talks about doing research and looking at youtube videos to overcome the issues she faced while attempting this FRQ. | 0.97 |
| Total | 0.9 * (1.0 + 0.98 + 0.97 + 0.97) | 3.528/3.6 |
Association
| Title | Grading Description | Score |
|---|---|---|
| FRQ 1 | Found a good and unique connection to the FRQ in her code, talking about a person class with a @manytomany and a @manytoone relationship, and connecting how they are essentially using arrays to hold the person data, much like how FRQ 1 used arrays to store data that is easily mutable. | 0.98 |
| FRQ 2 | The segment of code accurately reflects the goals of the FRQ and shows a deep understanding of classes. However, I wish you would've went more in depth about why we use classes, or just add a little bit more explaining the use of it in your code at the end. | 0.96 |
| FRQ 3 | The example described would accurately show the topics you described the third frq as having, classes and array-lists, in a way very similar to how they do it in the actual FRQ. However, there was no direct code segment from the original project for FRQ 3 actually showing the connection between the FRQ topics and your project. I also felt as if you could've went a little bit more in depth about the the importance of classes and array-lists in your issue. | 0.93 |
| FRQ 4 | The segment of code was an extremely good example of interfaces, basically mirroring the 2015 FRQ. The explanation was in depth, and easy to understand. She also talked about extra stuff she added to the JPA repository, and how she did it which was extremely interesting to learn about. | 1.0 |
| Total | 0.9 * (0.98+0.96+0.93+1.0 | 3.483/3.6 |
Question 1
While our project has not really required the use of 2D Array yet, we have used Arrays and ArrayLists heavily throughout multiple features of our project.
Below is the Person class that I made for our project, and was my main contribution. For the Person class, the roles will be stored as a List, which would allow us to work with roles in a much similar manner to Question 1. For example, we can iterate through the roles as a list to find everyone who matches the teacher roles, and give them different permissions accordingly.
We went beyond CollegeBoard in our project when relating to Arrays, since our project relies on relationships (indicated by @ManyToMany or @ManyToOne). These relationships create connections between databases/collections, like what we did with our roles and people objects, which are essentially made up of arrays.
One possible implementation of 2D arrays could be added to the statistics related functionality in our project. Data stored by the user would could have to be stored as a 2D array depending on the type.
Question 2
The purpose of this project was to create a Class. Our project is made entirely of classes. However, here is one that I made below. This class includes a method for instance variables, and a method for initializing the roles. Much of the work for creating a class is done through annotations, such as @Data and @Entity. We don't need constructor methods because of this
Question 3
This question was about SparseArrays, which used code to create a simulation of something that doesn't actually exist. The code from the problem never created an actual array, but we still manipulated the SparseArray by using objects to represent entries. We do something similar in our project with our randomly generated tables feature. We use code to simulate reality in a more simple and data efficient matter. If we wanted to improve this feature, we could include functionality that adds properties to the people we are organizing into tables, which would allow teachers to better control whether or not certain people are seated next to each other. These properties could be included in a similar method as entries.
Question 4
This question used interfaces and inheritance, two concepts that are seen again and again in OOP. Our JPA repositories are all an interface, which means we inherit everything that a normal JPA repository has already been written to do, and when we overwrite the parts that we need to change for our own purposes. Although we have been using interfaces long before this project, the FRQ allowed be to better understand how they work on a more basic level.