This year, my goal has been to build upon last year's success. Mainly by continuing my ventures into Hacktoberfest and Open source. My current project is to build a Nintendo64 emulator in Rust. Feel free to follow my progress on Github.
Through the above experiences, I have gained experience in contributing to a wide-variety of packages. This includes learning to follow through with feature requests from email and permissioning to implementation. In addition, I have learnt and applied a wide variety of skills that have proved useful for contributing. This includes the following.
These projects were completed during my time studying at Imperial. Unfortunately, the source code for some of the projects are not available as they are still used as courseworks.
Energy awareness for a specific program can be a difficult aspect to measure. This element is becoming
increasingly important in an increasingly energy conscious world. In software, enerrgy usage is
a difficult measure to quantify mainly because of the large amount of asynchronous and synchronous
aspects that make up an Operating System. With advanced schedulers, it is difficult to isolate exactly
how much energy can be attributed to a specific program. This is manly through the use of various
techniques that buffer and consolidate data across different programs. As such, isolating the energy consumption
of a specific program over it's execution can be difficult.
This project explores some of the current techniques that are available to profile energy consumption of programs. Within this project, I created a technique to profile the energy consumed by the CPU, RAM, GPU, battery and network components of a given program. This was subsequently tested across a wide range of benchmarks and energy efficient/inefficient programs that explore the effectiveness of my profiler.
I perform this comparison against a large amount of schedulers, governers and hardware along with general program comparisons between Firefox and Chrome. Further details of my program can seen in my thesis.
An AirBnB style app designed to fascilitate the sharing of common household items.
A supervisor at Imperial tasked us with creating a platform for the lending and borrowing of items. The
key idea was that the items aren't being used by their owner all the time, and so could be lent out to
others who need them. Sharify was created to bring about the closeness that neighbours in smaller towns
could have, where they would simply go next door to borrow something they needed.
Sharify was developed across three platforms: a website, an Android app and an iOS app. These were serviced by a backend that handled the users, items and transactions. For this project, I was responsible for the web-app for the site. For this site, I helped develop routes using NodeJS + Express and MongoDB. I was also responsible for setting up authentication and developing a test framework using Supertest and MochaJS. Finally, I helped design the client side iteractions using twitter bootstrap and JQuery.
An example prototype video for the site can be found here. Source code and reports for this project are available on request.
WikiMaster is a quiz app using questions that are automatically generated from Wikipedia articles. This app was unique in being capable of offering quizzes on any topic in the world.
WikiMaster is a quiz app using questions that are automatically generated from Wikipedia articles.
In this way, the app could quiz a user on almost any topic in the world, which we feel would be rather
In many ways, this project layed the foundation for our architecture and project flow that proved successful for future projects. For this project, I worked with others on the backend which was written using NodeJS + express. I also helped build the website using Bootstrap and JQuery along with design the database interactions.
This project was chosen to be demonstrated for the department's open day. Source code is available for this project on request.
Operating System Coursework
A copy of the specification can be found here.
This was a group project to implement Pintos under the specification listed previously. For this
project, we needed to
implement many aspects that are critical for Operating System designs. This includes a expansive
virtual memory system that
expands to multiple pages, user programs, scheduling alogirthms including priority donation and
This was a full x86 Operating System that was designed to be run on QEMU.
This project tested time management, C99 skills and skills managing concurrent access.
The WACC coursework was a custom language coursework designed to test the fundamental basics of compiler design. It was designed to convert a custom statically typed TOY language to ARM7 assembly. This project was written in Java.
This was a group project to implement WACC. This project was split up into multiple stages based on
and code generation.
For implementing this code, we used ANTLR4 for parsing. This provided a useful tree structure that was useful for traversing the code. Each of the three stages of syntax, semantic and code generation were implemented using this tree. This is because the tree enabled the use of the visitor pattern which was an elegant approach to only visiting the nodes that we care about.
As an extension to this project, we wrote a toy implementation of battleships that successfully ran on QEMU.
As part of first year projects, we created a ARM assembler and emulator in C. This was subsequently
used to write a custom
assembly script that ran leds in a specific pattern in bare-metal assembly.
A demonstration for this project can be found here.