Project 1
Published: 2023-10-15 01:40:16

Edited to include a couple responses from Teammates

Honestly, I had some difficulty on what I expected to be a fairly straightforward task. At first, I felt that the tests I were writing were too obvious. Then once I got past my compilation errors, I realized that there were tests for my tests (correct...?- this was some of my confusion when talking with our lead about problems he was seeing vs problems I was seeing), far too late; perhaps finding those would have given me better insight as to what direction to take with my code. Also, I recall wanting to do an extra test (something like 4 tests for a CC 3 method0: as I understood it should e three tests for a CC3. So part of my challenge was combining test cases into a single relevant case (eg a case for x=0 and a case for x=1 would be x<2).

Learning today that one of the programs, I believe gitKraken, combined the test files into one (I did not expect this as the name created "ArrayQueueTest.java" is not the same as "ArrayQueue.java" "DynamicArrayQueue.java" ... if it had been the same name, the merge would have made more sense to me. Two of my misconceptions were challanged: that many tests looked too simple and that creating these tests would be simple. While I did not encounter this problem, I learned in class discussion about the importance of coordinating with any team mates working in the same class, so as to not have conflicting method names.

Very similar to my earlier answers:   Run code coverage plugin to see which methods are called actually called the most. The class/methods called the most/by the most outside classes, should be tested throughly.  In terms of order, I would make sure that the internal methods are worked on first, so that they are operating correctly when the outer methods, utilizing those internal methods, are being tested. If any methods did not have dependencies, or had low dependencies & were not of the highest importance, I would assign these to my slowest performing team members. Team members that are fast, but usually needed some slight debugging, would be put on all of the CC1 problems. I would have either another [fast, but slightly more skilled] or [slower than fast but very competent] team member check their code. The next level of skill (above the person checking the fast CC1 work) would be put to task working on all of the higher CC problems; faster workers on writing code with their equally skilled but slower counter part checking over the work to make sure it all works harmoniously. In leiu of the work checker being equal but slower, they also may be equally fast but more skilled; if this is the case, they may take on a the role of a supervisor and can be support to other team members, when work to review has not arrived to them from the sub-teams. Finally the above supervisor, a team lead, or team member with this role specifically, would do a final check, perhaps cleaning anything up before handing it to another team. In a global context, there could be some team-specific effieciencies by utilizing members in one time zone to check the work of members in another time-zone. There could also be cost-effieciencies in by delgating certain time-consuming tasks to one workers in one economy vs another.