Author: Gloria Shin, Seoin Kim
Date: 07-Apr-2023
Course: CS 3500, University of Utah, School of Computing
GitHub ID: bestcreator01, seointhenerd
Repo: https://github.com/uofu-cs3500-spring23/assignment8agario-northkoreannotsouth
Solution: Agario
Copyright: CS 3500, Gloria Shin, and Seoin Kim - This work may not be copied for use
in Academic Coursework.
The Agario program currently has the following projects: AgarioModels, ClientGUI, Communications,
and Logger. It also has TowardAgarioStepOne, TowardAgarioStepTwo, and TowardAgarioStepThree as starting projects.
It implements code utilizing JSON serialization and deserialization, the networking code that we created
in the previous assignment, and Math to coding.
The AgarioModels project contains code that represents the game "world". It includes the "global state" of the world.
This will keep a list of all game objects.
The ClientGUI project contains the GUI code of Agario. This references the AgarioModels project and Communications project.
The Communications project contains the Networking codes that we made in the previous assignment. What it does is
helping communicate between Client and Server.
The Logger project contains the code that we made in the previous assignment. This will log the status of Agario, which would
help debugging.
1. Assignment Eight - Agario Client
Predicted Hours: 22
Actual Hours: 26
Note:
I feel like the time expenditures were pretty accurate, but this assignment got much more time than I expected.
I realized that I may have to do more reviews on labs and specifications.
Estimating time expenditures can be a challenging task, as there are many variables that can affect the outcome.
It's important to break down larger tasks into smaller, more manageable ones and try to estimate the time required for each of them individually.
It's also helpful to track your actual time expenditures and compare them with your estimates to see how accurate they were.
To improve your abilities, it's important to practice regularly and seek feedback from others.
Consider taking on new challenges and learning new skills to expand your knowledge and expertise.
Additionally, try to reflect on your strengths and weaknesses and identify areas where you can improve.
With consistent effort and dedication, you can improve your abilities and become more proficient in your chosen field.
1. DRY (Don't Repeat Yourself)
DRY is a principle that emphasizes the importance of avoiding redundancy in code.
It suggests that each piece of information in a software system should have a single
authoritative representation. You should write code that is concise, easy to read,
and more maintainable.
2. KISS (Keep It Simple, Stupid)
KISS is a design principle that states that software should be simple, straightforward,
and easy to understand. The idea behind KISS is that complex systems are more likely to
fail, are harder to maintain, and are more difficult to understand and use. By keeping
things simple, software is more likely to be correct, reliable, and user-friendly. The
KISS principle encourages developers to look for the simplest solution to a problem and
to avoid over-engineering.
3. YAGNI (You Ain't Gonna Need It)
YAGNI is a software development principle that states that a developer should not add
functionality to a system unless it is immediately needed. The idea behind YAGNI is to
avoid over-engineering and to keep the system simple and focused. Developers can focus
on delivering the most important functionality first, and only add additional functionality
as it is needed.
We worked on the project together, hence just used the main branch.
We decided to pop up a fun image when the client player dies.
Important note: Our splitting works when you left click the mouse. It does not work with pressing the space bar.
We did not do the testing with a MS test, but debugged with logger.
Almost all code for this project was completed via pair programming, with each member contributing
equally to the project. Therefore, there are no distinct sections of work that can be attributed to
any one member.
However, each member brought their unique skill set to the project, which helped to ensure its success.
Gloria was particularly adept at problem-solving and coming up with creative solutions to complex issues,
while Seoin had a keen eye for detail and was able to cath error and bugs before they became a problem.
Overall, this partnership was a great success, and both members worked collaboratively to ensure that the
project was completed to the highest standard possible.
One of the most effective practices that we employed in our partnership was assigning tasks based on
each member's strengths and expertise. By doing so, we were able to work more efficiently and effectively,
as each member was able to focus on tasks that they were particularly good at. For example, Gloria was
particularly adept at writing code, while Seoin was better at debugging and testing. By assigning tasks
in this way, we were able to make the coding process faster, as we were both able to work on tasks that
we were comfortable with and could complete quickly. Another effective practice that we employed was clear
and frequent communication. We made sure to have regular meetings and check-ins to discuss our progress
and any issues that we were facing. By doing so, we were able to catch potential problems early on and
address them before they became bigger issues. Additionally, we were able to give each other feedback
and suggestions, which helped to improve the quality of our code.
An area of teamwork that Seoin could improve upon is conflict resolution. It's important to recognize that
disagreements and conflicts can arise during any project, and it's essential to have strategies in place to
address them. Seoin should be open to discussing different perspectives and finding solutions that work
for both of them. Additionally, Gloria could to recognize the importance of addressing problems as soon as they
arise, rather than letting them fester and potentially grow into larger issues. Our team concluded that effective
communication is the most important factor when pair programming.