This file presents how I managed the project. In other words, how I distrubuted type and amount of work depending on project phase and circumstances. It also highlights the use of management tools like Jira and Gitlab.
- Planning, organisation and their phases:
- Managing risks
- Use of Gitlab
- Use of Jira
My organisation of the project could be split into several phases:
- background reading:
- Familiarizing with graph theory
- Identifying and understanding algorithms
- Recognizing and evaluating methods of teaching them
- Reading Qt documentation
- Finding relevant Qt examples
- I undertook investigation to verify the use case of MST as a near-optimal route.
I was intrigued by the claims that MST can be used to find near-optimal route from the article called “An Application of Minimum Spanning Trees to Travel Planning” (2010) by L Fitina et al. I wrote a code to verify accuracy of few statements from that article and presented my findings on page 14 of Project introduction document.
- tinkering with researched resources, trying to implement foundations for drawing a graph and implementing the first algorithm (e.g. drawing circles and lines to represent graph vertices and edges, implementing text-input fields for edge-weights).
During the challenge week I accomplished the following tasks:
- Formulated project objectives
These can be viewed in the Project introduction document - Documented summer coding
- Added facility to create and modify a graph
- Implemented a single algorithm
- Created extensive Project introduction document
At the end of the challenge week I created 0.1.0 release on Jira which contains all issues completed up to the challenge week:
Capstone project has no limit in terms of progress that can be made. So I decided to strategically postpone further work on it until I complete (or almost complete) all available assignments of other modules and afterwards focus entirely on the project. This way I could utilize all remaining time without fear of not giving other modules enough attention. This period lasted around a month, giving me another full month of project work before the interim interview.
During this time I spent most of my free time working on the project and implemented most of the program functionality, including:
- algorithm selection facility
- 4 new algorithms
- custom graph saving/loading
- selectable preset graphs
I slightly transitioned away from carefully considering every code addition (which I did during early design stage) into adding sheer amount of features. I documented each step of the progress by creating separate Jira issue for every task. Every time I marked an issue as "done", I wrote a short comment with links to relevant Gitlab commits, often with an additional image of what was implemented, or few lines of code (that fixed a bug for example). Here's an example of the comment added when priority queue task issue was marked as "done":
...and here's an example of the comment added after a sub-window bug issue was fixed and marked as "done":
The list of Jira issues created during this time can be viewed here.
Task issues included:
Bug issues included:
During that time I considered the development to be finished and made only minor changes to the code (fixing small bugs/typos). I focused on producing deliverables (abstract, poster, final report), and the coursework of other modules.
Online learning doesn't help to stay focused on studying. It makes it easier to get distracted. I tried to stay away from procrastination by frequently updating and checking Kanban board, and also by using physical board to keep track of important dates and tasks:
Polishing details before creating key program features could result in the following effect:
I prioritized implementing all algorithms first instead of trying to make each algorithm perfect from the start.
I tried to keep reasonable ratio of commits per amount of work done, being aware that infrequent commits would make it hard to track the changes and too frequent commits would be inefficient. As shown on image below, I used descriptive commit names, which helps to track the changes (and to reference them in Jira).
Very often while working on something I get multiple ideas on what changes to make. Using Jira and creating tasks for such ideas helped me to avoid forgetting them over time. Additionally, having saved issues in the "backlog", "selected for development" or "in progress" columns of the Kanban board is a good motivational factor to get them done. Throughout this document I used hyperlinks to reference Jira issues.