CS221 Final Week

The last item on the agenda for the group project is the finalisation of existing documentation, and the Final Report. Parts of the final report were handed out on during morning meetings on Monday and Tuesday. My role remains related to testing. Nathan and I produce the Test Report, as well ensure that the Test Specification is finished (that we have made all corrections needed based off the feedback). I filled out the Unit Testing table that is part of the Test Report. I also checked that my blog entries were completed and published. Lastly I helped to write the Algorithms section of the Final Report. As a group we had a final meeting in which I helped with configuration management and updating the project directory. Time spent this week = ~6 hours.

CS221 Week 8 & Integration Week

Week 8 [Kept as draft & published late – Added to the following week’s post]

The vast majority of discussion and work done by the group consisted of preparation for integration week. A major point of discussion in the meeting was the filesize of the exercise videos exceeding the GitLab limit. I suggested using VLC media’s Convert/Save option as a method of compressing the videos, although I am not responsible for editing the videos. The group decided upon compressing the resolution of the videos and using Google Drive as a temporary hosting alternative for now (for each build, the videos will need to be manually copied into the project’s Videos folder.
I made sure I was able to present the most recent build that Peter presented to the group. Besides that I didn’t have much to do this week.
Time spent this week = ~2 hours.

Integration Week

Following the first meeting of integration week, it seems my role will remain largely around testing. As a group we feel fairly confident that at the end of this week we will be able to produce a functional program. A lot of the coding work this week will involve tweaking minor aspects.
I noticed feedback from Chris on the Test Specification that we had not properly amended. A run of tests that together check for the primary ‘exercise routine’ function of the program involve tests that must be considered simultaneously to assess their pass criteria. Chris noted that this is not clear for the person using the Test Specification to run tests. He suggested collating this run of tests into a single entry, then adding a reference to an appendix entry that listed them as subtests. I implemented this suggestion.
I also made sure I could run the latest build of the program on my computer.
Time spent today = 3.5 hours.
Today I attended the meeting, and then drafted a Test Report template to be filled out whenever System Tests are done on the latest build. The template for the Unit Test reports is similar. I decided to omit the ‘Req being tested’, ‘Input’ and ‘Output’ columns in the template, as I thought that would be unneccesary clutter for someone who is reading the report. The tester filling out a report can just access the Test Spec for the precise instructions.
Time spent today = ~2 hours.
In the morning meeting I stressed the need for JUnit test to be added to the code. These tests should check individual methods, and in doing so test the proper functioning of their parent class. After the meeting I made attempts to start drafting these unit tests. This is something I have found difficult, for a few reasons. The first of which is my unfamiliarity with JavaFX (the use of which our code employs often). The second is that many methods in the code do not return some object or variable, but instead alter the state of its parent object in some way. I have found this to be difficult to write JUnit tests for and so I think I will need help from other group members, particular those more familiar with the code/program design.
Time spent today = ~7 hours.
I’ve had some personal difficulties today, so I missed the morning briefing. But I was present throughout the afternoon to the evening. I helped with tweaking the code, and as a group we made progress on testing the code against JUnit tests. By the end of the day we considered the program to be fully function according the Requirements Specification, so I filled out a Test Report on Draft 8.5. The final day should involve changing/adding only minor aspects of the project’s build.
Time spent today = ~4 hours.
For the final day the group spent most of the time cleaning up frayed edges of the code. I helped with adding JavaDoc comments to ensure the code had full documentation. I also assisted group members in getting the latest builds of the project to run on their machines. It seems there is some bug that makes adding the JavaFX library to a project more difficult. Also when we changed the program structure, it was necessary to invalidate caches to get the program to recognise class paths. I was further involved in some final tweaks to the directory and program structure before we released the finished build to the GitLab repository.
Time spent today = 8 hours.
In total, approximately 30 hours spent this week.

CS221 Easter Break

Easter Break
I wasn’t assigned a lot of responsibility over the Easter Break, it seems there weren’t enough tasks to go around. I stayed informed of any progress that had been made, and remained available in the Discord server to assist other group members.
During the first weekly meeting in the new semester, the group presented and discussed the progress that had been made. I raised a concern I had around our coding in features to the program that weren’t specified in the Requirements Spec, that it may be considered superfluous and so lose us marks. The conclusion was that it was okay, so long as the specified functionality was all present in the final program.
As a group we decided on a slot for the demonstration. Finally we made plans on the exercises that we would include in the program, as well as how we would record them and implement them.
Time spent = ~2 hours.

CS221 Week 7

Prior to the weekly tutorial, the group received feedback on the submitted Test Spec. Much of it referred to QA matters. Besides that the major concern was discord between the Test Spec and the UI Documents, which was amended by Aaron updating the UI Documents. After the weekly tutorial, the group had a particularly long (2-3 hrs) in which we chiefly discussed the Design Spec. I was assigned to help Nathan with composing Component Diagrams for the document.

On Friday we first compiled a list of all public Methods that are necessary in the design, and the Classes which initialise and access these methods. Nathan formed that list into a draft of component diagram using Adobe Photoshop, which I then formalised into proper UML using draw.io. This took around an hour.

The same day, the group had a review meeting for the Design Spec, presenting the work we had done. Following that meeting, my next task was to continue the progress that Bartosz had made on Sequence Diagrams for the Design Spec. Initially I was to modify the existing sequence diagram to reflect the changes made to the Use Cases in the UI Doc, but we decided the original diagrams were satisfactory. So, I made an additional diagram demonstrating the process of pausing/unpausing in the program. After that, I wrote short summaries describing each of the sequence diagrams we had made. Including time taken to further familiarise myself with the code, I spent approx 3hrs on this task.

On Tuesday, the group held the QA Review meeting for the Design Spec. I attended, and spent additional time after the meeting proofreading the doc and helping to configure the LaTeX file. Time spent: approx 3 hrs.

Total time spent this week: ~10 hours.

CS221 Week 6

Having submitted the Test Specification last week, Nathan and I have started to transition to new roles on the project. The element of principal concern is the Design Specification, a full draft of which we need to have ready for the next tutorial meeting.

Following the tutorial meeting of Wed 3rd we had our usual informal meeting. From this, I was assigned the task of writing the Introduction section of the Design Spec. I first thoroughly read the SE.QA.05 document to get an understanding of the contents and purpose of the Design Spec. During the weekend I spent a couple of hours writing an Introduction draft. After that I had a short (20 min)meeting with some group members where I showed my work, and we further discussed the Group’s plan for the Design Spec.

It will likely be another week before we recieve feedback on the Test Spec, so I expect to be assigned further tasks related to the Design Spec following the next tutorial meeting. Approximately 3.5 hours spent working this week.

CS221 Week 5

This week the group met for ~1 hour to discuss and give feedback on the Test Specification. A few days later the Test Spec group met with the JavaFX group to note areas in which the Test Spec disagreed with the current JavaFX build, which also took ~1 hour. I spent approx ~3 hours implementing the changes discussed in these two previous meetings. On Tuesday I spent a further hour tweaking some aspects fo the document, and then later in the day I participated in the Quality Assurance Review meeting for the Test Spec document. In total this week around 7 hours were spent working on the project.

CS221 Week 4

This week the group met to review the User Interface Presentation document and the Use Cases document. I pointed out a few details that needed addressing, and noticed that the UI Presentation needed to be updated to compy with SE.QA.02.

I did a small amount of work on the Test Specification this week. Formalised last week’s drafted tests, and ensured the Test Procedures table had a coherent Test Reference system. ~2 hours spent.

CS221 Week 3

This week, following the tutorial meeting, I wrote the introduction for the Test Spec. I first read SE.QA.02 to find out what should be included in the introduction, and how it should be structured. After that, I spent a few hours drafting an intro into the test spec .tex file. I also added a subsection detailing how the Test Spec should be used. Lastly I wrote drafts for 10 or so possible tests that could be added to the Test Spec. In total ~3 hours spent this week.

CS221 Week 2

During the second tutorial meeting, sub-groups assigned to tasks presented what they’d worked on so far.

Nathan screenshared our first draft Test Spec with the group. Laurence advised that the questions we had concerning our task be taken to Chris Price. On Thursday I met with Nathan and Aaron, we discussed what aspects of UI would need to be written into the Test Spec.

We were tasked for the following week to continue working on the Test Spec. Feedback from Chris Price caused us to rethink the structure of the Test Spec, in that tests should be written to naturally follow on from each other. Following this, I began work on the Test Spec as a LaTeX document (first refamiliarising myself with LaTeX). Next I rewrote the existing draft to reflect Chris’ feedback (which caused it to be more specific and repeatable), and then transferred the new draft to the LaTeX document.

I spent some time writing more tests into the Test Spec Doc, ensuring where possible that the Input, Output and Pass Criteria sections are specific. Last, I successfully uploaded a .tex file and a readme to the /docs folder on the group’s GitLab. ~5 hrs spent this week.

CS221 Week 1

Prior to the 24th Jan group meeting tutorial, I read through the Requirements Spec. During the meeting Laurence introduced the group project and discussed the nature of the weekly group meetings. The group volunteered for various tasks to report on by the next group meeting and I, along with Nathan, was tasked to start work on the Testing Specification.

I read through SE-QA-06, and then the following Tuesday met with Nathan. Following that we individually wrote out some System Tests pertaining to different FR’s, which I then compiled into a Word Document containing a first draft of the Test Spec. We noted a few questions we had concerning the tests we’d written, to be brought up in the next group meeting. Time spent: ~approximately 4-5 hours spent this week.