A selection of projects I have completed during my degree and in my spare time.

Applied Statistics Miniprojects

A collection of four small projects given to test my understanding of statistics and how I can use the R programming language to implement statistical methods. Information on these projects can be found on the subpage linked below.

EBS - Event Booking System

This was a group project to design and create a large application. I decided to come up with my own idea rather than use a given one (health monitor, car rental app, etc) and the group decided to go with it. The program allows an events management company to keep track of events they have planned as well as add and remove events, locations and customers from the system. The system also automatically emails customers when a user books a ticket on their account. Full details of the system and a walkthrough of what it looks like can be found on the links below.

C++ Offline Movie Database

This was a solo project to port my OMDB code from my 2018 project to C++. This project taught me the differences in OOP between Java and C++. As I hadn't used C++ in a couple years it was useful to have a refresher on the basis, as well as learn new techniques such as Header files, operator overloading, inline statements and the C++11 feature, shared_ptr.

Word Auto Completion with Tries

This project was designed to test my abilities with Data Structures, in particular with Tries. The program takes a given excerpt of text and a set of queries (part-completed words). A dictionary of words and their frequencies are taken from the text excerpt and loaded into a trie. For each entry in the queries list, it scans the trie and saves to a text file the top three most likely words that query could result in, along with their probabilities. This program could easily be modified to work in real-time where the excerpt of text is a sample of the user's previous words typed and the queries can be what the user is currently typing, thereby working as a real-time auto-complete feature.

Java Card Game

This was a solo project to implement a version of the card game 'Cheat'. The project was in two parts - the first was to write the classes to handle a card, hand and deck and the second was to write classes that defined how different strategies (computer player difficulties) would be played, as well as ensure the game worked correctly. One of the strategies had to have been thought up from scratch with no hints, and my implementation of that strategy was successful in consistently playing 15,000+ rounds against itself in a single game.

Analogue Electronic Communication System

This was a pairs project where the brief required us to design and build two circuits to modulate and demodulate a signal so it can be transmitted through a metal bar. The modulator consisted of a breadboard containing a signal in (from a PC via a 3.5mm phone connector), a pre-amplifier, an oscillator (set to the resonant frequency of the metal bar) and a power amp leading to an output which connected it to the metal bar. The demodulator was a printed circuit board which we designed in Autodesk EAGLE using a provided circuit diagram and had manufactured on site. We then needed to solder on the required components and make presentable by housing in a plastic container. We had to demonstrate that the system we had built was suitable for purpose by showing the output from different stages on a digital oscilloscope as well as playing the transmitted audio from headphones connected to the demodulator output, as well as answer questions on the circuit design and operation.

Thread-Safe Memory Manager in C

This was a solo project in three parts to build a memory manager in C. The first part required me to build functions that would initialise a block of memory by requesting it from the Operating System, then allow segments of the block to be allocated and deallocated to programs at their request. The second part built upon this by modifying the initialise function to accept a function pointer which allows the user to define what algorithm the allocation function should use to find the next free block of memory. The third part of the project involved ensuring the program was thread-safe and could run correctly on multiple threads using Linux POSIX system calls and the C pthread library.

ARM Assembly Programming

This was a solo project designed to test my ability to take a high-level description of a simple cryptographic algorithm and convert it to C code, then take that C code and convert it to ARMv7 Assembly to run on a Raspberry Pi running Arch Linux. On both versions, the program takes a message over stdin along with two private keys and either encrypt or decrypt the given message using a simple ROT based cypher, depending on what command line argument is used.

C Offline Movie Database

This project is a port of my previous Java Offline Movie Database to C. It was a formative project where the given grade did not count towards the overall degree grade. This allowed me to learn the basics of C syntax including header files and file I/O.

Data Structures and Algorithms - Feature Vector Calculator

This was a solo project was designed to test my knowledge of algorithms by taking an informal description of an algorithm, describing it in pseudocode, assessing the runtime complexity of that solution, implement the algorithm in Java then run timing experiments and report the findings. The first algorithm created Feature Vectors of two documents by comparing Documents A and B separately with a Dictionary of words, Q. It then compared the two Feature Vectors to create a Document Similarity Distance between A and B, showing how similar the two documents were to each other (the lower the DSD, the more similar the documents were).

Digital Electronic Traffic Light System

This was a pairs project to design a digital circuit from scratch using discrete logic to simulate a system of traffic lights at a crossroad. The system was built in modules in Quartus Prime and compiled onto an FPGA unit which interfaced with a custom board of LEDs and switches to simulate the traffic lights and car sensors on the crossroads. The system was designed so that the default state of the system was the lights were green on the main road and when a car was sensed, a timer in the system would ensure 8 seconds have passed with the main road being green before transitioning the lights to red on the main road then green on the side roads. The lights remain green for 4 seconds before transitioning back to red and the main road goes green once more. An additional module was built to allow the system to count how many cars were waiting on the side road as they activated a sensor and display this count on a seven segment display.
The system required us to build Truth Tables for the logic (and simplify them with Karnaugh Maps) and build a Mealy Machine to describe the logic of the system at a higher level, before building the system component-by-component in Quartus.
My partner and I split the work by working in a Pairs Programming style, with the driver and passenger switching roles either 60 to 90 minutes. We found this worked really well for us since we would often know how to solve an issue the other had, or in one case the passenger could double check the logic of a solution while the driver placed the logic gates in Quartus.

Bookshop Database System

This was a solo project to design a database to hold information on books, staff and sales for a bookshop, using a PostgreSQL database and a prototype web interface in HTML5 and CSS3 with a Python backend utilising psychopg2 to connect to the database. This required me to understand how PostgreSQL stores databases, how queries are passed through the system and how to ensure data coming back from the database is displayed to the user.
To produce a working system, I had to form complex SQL queries that either sent specific information to the database through a web form, or retrieved specific information from the database and display it correctly to the user. I also had to do input validation on all data given by the user either on the server backend or via domain constraints on the database itself and ensure the user received a suitable error message should the validation or connection fail. I then had to document my system working as expected, and failing safely when the wrong data was input.

Java Toll Road Simulator

This was a solo project to understand some more intermediate aspects of Java including Exceptions, Enums and interfaces as well as aspects of Software Engineering including UML and how to correctly lay out a project from the outset.
The system I built is for keeping track of vehicles that register for a toll road, and for registering transactions of people topping-up and using the toll road. I implemented custom exceptions that are called when a transaction is processed and either the vehicle / account is not registered or the account does not have enough money.

IoT System Development

I was the group lead for a 4-person group project in Systems Development, where my group was tasked with coming up with two IoT solutions for a family with specific needs. We had to write a report giving a mission statement for both devices, personas, requirements and use cases, explain our development approach, produce a Gantt chart and highlight and risks involved. We then had to produce a paper-based prototype of the user interface for our system and talk about critical success factors and professional considerations.
Finally, we needed to perform a presentation on our systems to a panel of three reviewers and a portion of our class, and answer questions presented to us on the spot. Both the report and presentation are linked below in one document.

Java Offline Movie Database

This project allowed me to show understanding of basic Object-Orientated Programming in Java by building a system that would take in a formatted list of movies and output answers to queries about the movie list.
I was required to understand some basic Java concepts such as instance variables, methods, file I/O, collections and the comparator interface, as well as how to define real-world objects using classes and the use of test harnesses to ensure classes are creating objects as I'd expect.

Web Design with Python

This was a pairs-project which required me to understand how to write code in Python and use the Flask framework to create a backend for a simple site written in HTML5 and CSS3. I was part of a two-person group where I largely worked on the backend and logic where my partner worked on the frontend CSS and much of the content, though be both took an interest in what the other was doing.
Part of my job was to understand how to parse a CSV file in and pull out the needed information, how to validate information entered into the webpages and compare it to what was stored, then either record the information or present an error to the user. I used JavaScript to do some validation and add a date picker. The system also required an admin login system to allow a verified user to approve or delete information stored in the system.

Lo-Fi Prototyping Exercise and Presentation

I was project lead on 4-person assignment to design and document a paper prototype booth for an interactive help console. Our group was given a couple requirements and had to decide which features should be included and guess at what the user would want, then design the look of the booth and user interface slides from cardboard and foam-board, which was then presented to an assessment board to be questioned.
To complete this project at a satisfactory level, I needed to understand some elements of UI design and accessibility, how to present technical information to the user and describe how the group organised the project, kept in touch and developed our physical prototype.

Machine Code Programming

This project required me to write simple algorithms in very low-level code that ran on a custom-designed CPU emulator with very small instruction set, called a Brookshear Machine. To do this, I first wrote out the pseudocode of what I wanted my algorithm to do, then I decided which registers, operations and memory locations I would use before writing, testing and iterating the machine code in the Brookshear Machine. Once my algorithm worked correctly I then revised each implementation to ensure it was as efficient as possible while still carrying out the required operation.
This project taught me the fundamentals of writing low-level code including how to properly structure a project when dealing with registers, opcodes and accessing memory manually.

Database Design

I was part of a two-person group assigned to design 10 queries in SQL for a backend database (PHPMyAdmin) and design a frontend in HTML and PHP (using little CSS) to handle input related to those questions. We agreed between us to divide the work by taking a question each and collaborating live over VoiP, taking the next question in line when complete then both testing for any issues once we were finished.
For the project itself, we were given tables populated by the necessary fields and had to work out and connect the foreign keys as well as make up some sample test data that should cover any scenario. The queries we had to write ranged from simply designing a button which populated a HTML table with the database table's data when clicked, through to more complex queries where I needed to insert data to multiple tables in one PHP form, or pull through data from multiple database tables while avoiding Cartesian products.

Modelling of Business Systems

For this project, I was given the outline of a business that was looking to upgrade their systems from paper-based to electronic and asked to model what their current system is based on the given outline, in order for an electronic system to be designed. This required understanding where things seemed to work well in the current system and where there were conflicts, and make correct assumptions based on the partial outline we were given.
To do this, I utilised several modelling techniques including Rich Picture, Context Diagram and Data Flow Diagrams, and made statements where I had assumed missing data.

Individual C++ Exercise

This project was designed to test my knowledge of basic C++ by programming a command-line version of the game Bulls and Cows. This project required use of basic I/O such as cin and cout, stringStream, loops and conditionals. I was limited to only using built-in libraries and the code had to personally be written by myself. I was given a function that utilised Bitset but was not told what it did or how it should be used, only that I was expected to use C++ documentation to understand.
The first part of the project required me to build a way for the user to guess a code that the computer generated, which required knowledge of how bulls and cows are counted in the game. The second part of the project was to allow the user to define a code and find a way to make the computer guess what that code is. This required knowledge of how to track and narrow down a set of possibilities with limited information given in order to find the correct answer over several tries.

Website Design

As part of an introduction to web design, I was given the task of designing a responsive website for a canoe club based in Norwich, UK. The constraints I was given were that I could not use any backend services (and no control over any server-side scripts), no use of JavaScript and no external libraries (though additional font packs were allowed). This pushed me to utilise as many features of HTML5 and CSS3 as possible.
To fulfil all the design requirements for this project, I needed to create a site that validated correctly, was easy to navigate with accessibility in mind, was responsive to resizing, embedded external features (such as maps), featured an image gallery, embed social media links and ensure it ran the same in all modern browsers.

Who I am

I'm currently a third year Computer Science student at the University of East Anglia in Norwich, UK, graduating in 2021. After some years of working in the Housing sector and many years being interested in all things tech, I decided to leave my former career in 2017 to study full-time for a Bachelor's Degree in Computer Science with a focus from the start on AI and Machine Learning. I have had a wide range of interests within Computer Science as detailed below.

Java Programming

Java is my go-to language for personal projects, I'm even using it for my capstone project in my third year for creating tools for a Machine Learning toolkit. I like to keep up-to-date with the latest happenings with Java through Reddit communities and through conference videos on YouTube.

Developing Secure Applications

I developed more of an interest in computer security after working on user authentication in Java for my Event Booking System project, which led me to studying two modules on it in my third year.

Machine Learning and Artificial Intelligence

I had been interested in the impact smaller projects in ML were making to computing back before I left my former career, so after researching it in more detail, I decided that would be the field I would prioritise going forward. I am also taking two modules in this in my third year.

C++ Programming

I've so far completed a couple small projects in C++ in order to understand how it differs from Java and to get a solid understanding of the use of pointers, however I'm moving away from using C++ to focus more learning on Rust, due to the latter's inherent security benefits.

Developing for the Web

Although it hasn't been a focus of my time, I've find myself working on web apps and sites quite often. HTML5 and CSS3 are a given, of course, but I've spent quite some time on SQL databases too - SQLite, Postgres and MariaDB - and understanding the best ways to move to and from them efficiently as well as how to securely store data within them.

Software Development Lifecycle

I have experience with Agile Development concepts such as prioritising interactions over processes; producing software over documentation and responding to change over following a solid plan, after having used these concepts to manage a couple small group projects. These projects have also required knowledge and use of UML, Class Diagrams, ERD and OOP principles.

Digital and Analogue Electronics

I have completed a small project programming a bare metal digital circuits in the form of an Intel FPGA which was used implement a state machine to control a set of traffic lights. For an Analogue Electronics project, I built a modulator and amplifier to transmit music through a metal bar, and used a demodulator circuit to turn it back into an audible signal.

Get in touch

If you would like to get in contact, feel free to send an email to the below address and I'll get back to you when I can.