Jyustin
commented
7 months ago Bonus scoring graded 1.125 basis
GRADER: Justin Nguyen
Frq 1: 1. complete with running code with a small reflection at the end. Frq 2: 1. also completed with running code, with example runtime. also has a reflection at end which focuses on the main focuses of the frq. Frq 3: 1.1. Frq completed with running code and discusses research into FRQ topic at the end. The explanation for frq is thorough. Frq 4: 1.1. Frq is completed with running code and elaborates on the topics utilized within the frq at the end.
| (+) I like the content of reflections. feels like you really learned something from frqs and also explained it in a way which could even help others learn the topic. (-) You can talk about how you solved the problem a bit more. It feels like you just solved the problem and talked about the topic, but perhaps you could talk about solving the problem itself? Theres not much discussion on the frqs themselves, just the topics which could be ok. | frq | score |
|---|---|---|
| 1 | 0.9 | |
| 2 | 0.9 | |
| 3 | 1 | |
| 4 | 0.95 |
3.75/3.6
FRQ TO PBL GRADE: 3.65 total (+) relations between PBL and frqs are displayed and clearly shown. (+) writeups feel thorough and display a high level of understanding without dragging on. (-) the reflection is kind of long, I don't know if Mort has the patience to read all of that tbh. It's good content but I think extra code has a bigger impact most of the time. (+-+) relating person.java to frq is smart in a way. It's something everyone understands and your explanation of its relation to the frq makes sense. But in your pbl to frq I only saw one cool thing in frq 1 pbl relation, the rest was code I could recognize from my own project.
I think a mix of both recognizable code segments and cool code your team wrote is good, but I think there's a lot of generic code I've already seen here.
I could also just be completely wrong and just writing stuff to get more points (~>~)
Blog or describe how PBL/CB are teaching similar concepts in regards to Java. Expecting clear, well described, and well formatted associations between FRQ to Java Code contained in final project. Focus in on key themes for associations, i.e. if theme of FRQ is 2D array and you specify key algorithm, show how 2D array usage in final project is similar.
FRQ 1: 2D Arrays and Arrays/Array List
The main focus of FRQ 1 was manipulation of 1D and 2D arrays and using conditionals to test if the elements of an array are diverse. GamesessionApiController.java:
We didn't directly use 1D or 2D arrays in our PBL, but we implemented a leaderboard to rank users based on their game session times. The part List sessionList acts like a 1D array, where each element represents a distinct game session. For each use we traverse their list of game session times with nested for loop to find the minimum time, which is similar to iterating through a 1D array, like in the FRQ where we iterated through to check if the sums were unique.
FRQ 2: Classes
This FRQ focused on Java classes and the necessary components within it, such as private instance variables, constructors, and methods. We create a HiddenWord class and used OOP and string manipulation to for a word guessing game. Person.java:
For our PBL we implemented a public Person class for the login feature. The Person class has private instance variables of a person (email, password, name, dob, roles), constructor to initialize the object from the API with all the information, a custom method getAge calculates the age from their dob, and getters. It is a pretty standard Person class for login.
FRQ 3: Array/Array List
This FRQ introduced me to the concept of a sparse array, which is a data structure that represents arrays with a default value of zero and stores non zero elements in it, and how to access values, iterate through, and modify it. We didn't use sparse arrays in our PBL, but I think using the concept of our sparse array for the spot the difference game for phishing emails could be really useful if we were to implement it with images. The images could be represented using a sparse array of pixels, where the normal parts of the email image are the "default zeroes" and the suspicious parts would be the "non zero elements". Then based on where the user clicks, check if the point for where they click are at the same position of where the suspicious parts are represented in the sparse array. This would be helpful in optimizing memory usage in improving the efficiency of the game. We would only focus on storing the coordinates/pixels of the suspicious parts and reduce the amount of data overall we need to manage, which is important especially since we would want to use a high-resolution image. Using a sparse array would also be easy to update the position of the suspicious parts in each phishing email scenario as the levels increase, as we would adjust the positions.
FRQ 4: Methods and Control Structures
This FRQ dealt with interfaces, classes, methods, etc. to check if a number was in a group or multiple groups. I was a little confused with interfaces and classes at first so I did some research, basically a java class can inherit another class and multiple interfaces, while an interface can inherit other interfaces. Interfaces allows for creation of a contract that specifies the behavior that a class must implement. In our project, we used inheritance with public interfaces in our login feature. PersonJpaRepository.java:
PersonJpaRepository interface handles data access related to Person entities, which represent the users in our system. It extends "JpaRepository<Person, Long>" to inherit the methods for standard CRUD operations specifically for Person entities. Within this interface there are methods crucial to the login process like findByEmail(String email) to retrieve user info based on their email, and findByEmail andPassword(String email, String password) to verify and authenticate user credentials. Also, custom queries like findByLikeTermNative(String term) allow for more complex search criteria, which could be used for features such as user search.
Overall Reflection of FRQ to PBL
After doing these FRQs and associating the key concepts between each FRQ and my group's final project's key concepts, I better understand what I need to work on and what concepts I have proficiency in.
The questions that I struggled on and need to work on those areas are FRQ 3, that dealt with sparse arrays, and FRQ 4 that dealt with methods, control structures, and interfaces. I had a hard time combining each part of the problem together and filing in the incomplete parts in a way that actually make it into a running program. Also specifically for FRQ 3, the sparse array really confused me at first so I had to use external sources to understand it. In the context of the AP exam, it's critical to thoroughly go through each condition and given piece of information while managing time to best understand and implement their requirements. I also need to understand when to convert arrays to strings, and iterating and modifying collections (ArrayList). I think I've become better at using a main method for testing and traversing of 1D and 2D arrays with iteration (for, while, nested loops, backwards, etc.).
Even though for several of the problems, College Board doesn't require us to completely finish each part into a running program, I must be familiar with these concepts as the are utilized in the bigger picture, seen by the associations between the FRQs and our PBL. A main goal I have for trimester 3 is not only just studying/completing FRQs, but also drawing relationships between them and our projects to make sure I am fully understanding the concept and how to implement them in a working program. This will strengthen my readiness not only for the AP exam, but also my programming in the future.