Swift Realm

An updated version of Timed Progress which has been released on the app store

Overview

I built this application with the intention of bettering my time management. The base concept of the app came from Universities 'hours per credit' systems where they prescribe a recommended amount of time to focus on each module per week. For example, a 20 credit module would be 200 hours of work. Working off this concept my app lets you add tasks with their required hours per week so you may: view this progress, see if you are hitting the goals and see whether you are neglecting certain modules.

I later expanded this focus on Uni life and added individual tasks. These are tasks with deadlines (such as a coursework or dissertation), again you would prescribe a target time to complete this task.

Features

Adding, deleting and editing tasks

For this project I didn't see the need to store user data remotely as the only benefits I could see for this type of data storage were syncing between devices (which is unlikely as the code is only for one type of device), or as a fail-safe in case local data is lost (this data is likely not that important to the user). As this is not enough to justify the costs, I instead opted to store all data locally through the use of Realm as this is a relatively friendly database management system. This is excluding the feedback form which does use Firebase as this is information I need access to.

Timer

In this app there are three types of timers; continuous, countdown and Pomodoro. For this I created an interface which all the timer models followed, for simplicity and consistency the Pomodoro actually uses the countdown timer model just in a smart way. The basic way these timers operated was by storing the start time and publishing to the main thread each second, this structure meant that when the app goes into the background the timers are not affected. The important thing here is that cancellables are in fact cancelled when no longer required to ensure unnecessary updates are not published to the main thread.

Sorting Tasks

For this I used a bubble sort as this will likely be a list under 15 or so items and so the extra code complexity of a merge sort, quick sort or any other O(n log n) algorithm would not me worth the impact on code readability.

Live Activities

This part was a real challenge for me as I had never programmed any widget, let alone a live activity. The main difficulty in this came from giving the appearance of a timer counting down without actually calling requests from the app. For this I got the start-date and end-date and used a type of text object which changed depending on the current date. When the button paused the timer a live activity was updated and I substituted the text object for a static text of the current time. When the button played the timer a live activity was updated with new start and end dates. This meant that live activities only called upon the app upon creation, playing and pausing.

Tech Stack

• Programming Language: Swift
• Development Environment: Xcode
• UI Framework: SwiftUI
• Database: Realm
• Feedback: Firebase

Python Group Project

A third year data science project where as a group of 6 we developed a real-time sepsis predictor.

My Primary Contributions To This Project

• Researched sepsis symptoms to better understand how the features given in the dataset would likely correlate to the symptoms
• Participated in the initial data exploration of the non-continuous features. This consisted of both non-parametric techniques such as finding means and standard deviations before producing a Mann-Whitney U test and JSD plot, along with parametric techniques such as box-and-whisker plots to help us further understand the underlying structure of the features and why some that were expected to be good were not. An example of this is age where it was a poor metric due to its very equal dispersion between sepsis and non-sepsis patients.
• Researched the medical scores used. This consisted of producing a SHAP summary plot of all features of the dataset after these medical scores had been added. A XGBoost model was then produced with this new dataset so its precision, recall, F1-score and AUC score could be compared.
• Created the transformer model, this consisted of further imputation and feature selection to ensure the model was not overfitted through its excessive number of features. These features were selected based on their low correlation with other features and their level of missingness to reduce imputations effect on feature quality. For training the model early stopping was implemented to reduce overfitting and the GPU utilised to ensure this was done quickly. Finally, testing consisted of taking the model from the epoch loop with the lowest value loss and testing it in a way consistent to that of the other models.

Tech Stack

• Programming Language: Python

Swift Realm

A mobile app where you can schedule deadlines or weekly habits along with their estimated time for completion and track timed progress

Overview

I built this application with the intention of bettering my time management. The base concept of the app came from Universities 'hours per credit' systems where they prescribe a recommended amount of time to focus on each module per week. For example, a 20 credit module would be 200 hours of work. Working off this concept my app lets you add tasks with their required hours per week so you may: view this progress, see if you are hitting the goals and see whether you are neglecting certain modules.

I later expanded this focus on Uni life and added individual tasks. These are tasks with deadlines (such as a coursework or dissertation), again you would prescribe a target time to complete this task. Along with this I added in an advanced feature where you could alter the time blocks you would like to work towards the target in, meaning the timer could count down from a different starting number depending on the task being completed.

Features

Adding, deleting and editing tasks

Due to only writing this project in swift, with the intention of it being used for iPhones and iPads, I didn't see the need to store user data remotely as the only benefits I could see for this type of data storage were syncing between devices (which is unlikely as the code is only for one type of device), or as a fail-safe in case local data is lost (this data is likely not that important to the user). As this is not enough to justify the costs, I instead opted to store all data locally through the use of Realm as this is a relatively friendly database management system.

Timer

The challenge I found with the timer is ensuring it persists when the phone is sent to sleep or the app is sent into the background. To get around this I decided to store the timer start time in a plist as this is a small amount of data which does not need to be searched or ordered and so a database would be overkill. The use of a plist in this instance would likely also result in quicker retrieval which is important to ensure the timer has less initial lag upon re-entering the app.

Sorting Tasks

For this I used a bubble sort as this will likely be a list under 15 or so items and so the extra code complexity of a merge sort, quick sort or any other O(n log n) algorithm would not me worth the impact on code readability.

Tech Stack

• Programming Language: Swift
• Development Environment: Xcode
• UI Framework: SwiftUI
• Database: Realm

Go AWS Servers

A game of life modal that processes each round concurrently either via the computers cores or via multiple servers

Overview

This is a coursework for the Computer Systems A module. For this you are given the skeleton code to help you implement a sequential GOL model. After this you utilize threads to process the model on multiple cores through splitting the image into strips. After this you are tasked with creating another implementation, however, this time via servers.

Note, due to this being a current university coursework I am unable to make this repository public.

Features

Parallel Version

For this side of the project split the image into strips then ran the model upon each strip via threads. These threads communicated their results through channels to construct the next stage of the model. It didn't go much further with the only extra feature being a halo implementation which ensured neighbouring threads would only communicate their effected lines to one another rather than their entire strip.

Distributed Version

For this side of the project we used RPC calls and a stub file to communicate with a broker server which in turn split the image into strips that were then sent to 4 worker servers to be processed. Mutex locks were used to ensure that threads were not reading old information. After this we integrated a form of fault tolerance into the system so if the model was paused on the client side the servers running the individual threads would also pause, maintaining that stage of the model. This concept also worked the same if the client crashed, meaning the next client to join would pick-up where it left off.

Tech Stack

• Programming Language: Go
• Infrastructure: AWS Servers

Group Project C# .NET Avalonia

An exhibit for Bristol Museum where visitors interact with 3D replicas and information about that replica is displayed

Overview

This was a team project I did as part of my Software Engineering Project module. As a group of 5 we split into two sections; front-end (Daniel and Sergi) and back-end (Milosz, Thomas and I). For the front-end Milosz and I primarily worked together as this was my first time with front-end development, and my first time working in C# or with Avalonia. Due to this we started the project with my code being written primarily through pair programming techniques. Alongside Milosz I coded the first iteration of the information display (for the MVP) and the layout of the projection circles (for the 2nd and final iterations).

After some time getting used to the language I was then tasked with doing more code individually. During this I coded the hotspot positioning screen where hotspots could be positioned and resized.

After this we ran a user testing day with the second iteration of the project. During this we let users interact with the hotspots and gave them tasks to complete on the editor before filling out a few forms to help give us a direction for the final iteration.

After the testing day I once again worked alongside Milosz to implement the requested changes found on the testing day. For the front-end we focused on the animations for activated hotspots. Once complete we then met with the client of a third and final time to share out thoughts.

Tech Stack

• Front-End
• Programming Language: C#
• UI Framework: Avalonia
• Framework: .NET
• Back-End
• Programming Language: Python
• Computer Vision Libraries: OpenCV, MediaPipe
• Interoperability: Python.NET

C# .NET Avalonia Shell Script

An Application where a collection of images can be reorganised automatically based off features within those images

Overview

A friend who works for a rowing photography company came across a problem when a bunch of boats set off at a race out of number order. Due to this the photos from this race could not be split into the usual groups of 50 that they would usually be split into. To solve this he wanted an app which could extract the bow number from the image and sort it into the correct folders. As someone who used to row and so had been to this photography store occasionally I recommended that we also added in the boat code (this is a number on the side of all boats which is used to identify a row club) this way the images could also be sorted per club making it easier to go through these photos with your friends.

To start this I began on the front-end since I had recently completed this on another project. For this my plan was to split it into sections:

1. Select features to be extracted
2. Select target folder where all the images are held
3. Process the images (runs the python script with the parameters given in the previous 2 sections)
4. Structure the folder (deciding where each feature should impact)
5. Order the folder (looks at the images metadata and reorganises the folder to the new structure via a shell script)

As this is a large project to do individually I decided to structure it so all buttons, boxes and colours would only need to be changed in one place. This way I could focus on delivering a functional product first (the worse looking UI also benefits user testing as they focus criticism less on colours and shapes and more on the core functionality as it appears to be in early stages). With this I worked through all the bullet points above (leaving out the actual calling of the python script as I was yet to write it).

Next I focused on the organising of the folders post metadata tagging. To do this I created a folder and tagged 50 photos with various boat codes and bow numbers using a quick script so I would have test data for this task. To sort the photos I decided to use a shell script as it seemed like the logical language for desktop iteration.

My final task is the back-end and the feature extraction, this will be difficult as some images will cut out these features. Due to this I plan to run two scripts concurrently. The first script will attempt to extract these features from as many images as possible then the second script will extrapolate using the order of images and the colours within the images (boats vary in colour and so do the kit per club). This is where I am currently up to in this project.

Tech Stack

• Front-End
• Programming Language: C#
• UI Framework: Avalonia
• Framework: .NET
• Back-End
• Programming Language: Python
• Interoperability: Python.NET
• Automation
• Folder Sorting: Shell Script

Python HTML/CSS/JavaScript PHP MySQL

An ANPR system for automatically opening gates at a rental unit site. Has the ability to add and remove companies as well as log all entries

Overview

This application was split into two sections; the ANPR system and the web app. For the ANPR system it would read the number plate then look at the database to see if it was present. If it was it would then open the gate and add to the entries table the time, plate and company who entered.

On the web app side there was a primary user page where the owner of the entire unit site would log in and could add/remove companies or number plates for those companies. Along with this the primary user could also open the gate from the app and view all details such as which number plates are for which companies and all the entries to the site. For the secondary users they could only request new number plates and open the gate from the app.

Features

Reading Number Plates

To read the number plate the system would first search for a car using tiny YOLO. If found it would crop the image to the bounding box of the car using Matplotlib then use OpenCV to grey scale it before searching for rectangles. When a rectangle was found it would then crop the image a second time so it is only the number plate. After this it would save the image and call the Pytesseract to read from this image, extracting the number plate.

Tech Stack

• Automatic Number Plate Recognition (ANPR)
• Hardware: Raspberry Pi, Raspberry Pi Camera
• Programming Language: Python
• Libraries: OpenCV, Pytesseract, Numpy, Matplotlib, imutils, PLI
• Web Server
• Server: Apache 2
• Front-End Technologies HTML, CSS, JavaScript
• Back-End Language: PHP
• Database: MySQL

Python

A UI used to help log my world record into a database to be submitted as evidence of completion

Overview

During the covid year there wasn't much to do so a friend and I decided to attempt a rowing world record and row for more than 5 days straight. To verify this you had to have both a witness and a log. This log had to show when each person on the machine swapped over, the distance they had completed and had to ensure the workload was no higher than 40:60 between the athletes. Due to rowing machines not typically being used for such distances they had a pre-built reset at 50,000 meters. This would make calculating the distance per interval and the overall ratio challenging due to the sleep deprivation. To solve this I decided to program a GUI where we could enter just the distance the machine read at the time of the swap and the intervals time and the rest would be calculated, displayed for us and written to a database to be used as proof.

Tech Stack

• Programming Language: Python
• UI Framework: Tkinter
• Database: SQLite3