Home Projects Academic

Academic Projects
@ Warwick

Thesis and coursework projects during my undergraduate studies at the University of Warwick.
Please contact me for access to the code/report for a project if not already provided.

Card image cap

Derivative Trade Manager (Year 2)

Software Engineering coursework sponsored by Deutsche Bank, involving the design and implementation of a full-stack application to manage derivative trades.
  • Worked in a team of 6 people, modularising and delegating the work for optimal collaboration.
  • Went through the full process of Software Engineering, from Requirements Gathering to Design to Implementation, writing detailed reports at each stage.
  • Frontend built with React (JavaScript), backend built with Java and an SQL database, providing a REST API to the frontend for communication.
  • Automatically learns, detects and corrects input errors using AI via a Naive Bayes model.
  • Highly scalable implementation via pagination and indexing for queries.
  • Robust and fully documented API detailing the endpoints.
  • Large report detailing the implementation, with state machine diagrams explaining the UX-flow, UML diagrams explaining the class structure, and UI wireframes.

    • Java   JavaScript   SQL
    Card image cap

    Timetable Scheduler (Year 2)

    Artificial Intelligence coursework involving the implementation of a class timetable scheduler in Python.
  • Abstracted the problem into a game of "Tetris".
  • Modelled the task of scheduling the timetable around the various time and cost constraints as a Constraint Satisfaction Problem (CSP), and implemented CSP solving algorithms to find the optimal assignment.
  • Found the optimal assignment by implementing Informed Search algorithms.

    • Python
    Card image cap

    Physics Simulation Optimisation (Year 2)

    Advanced Computer Architecture coursework, involving the optimisation of a two-dimensional computational fluid dynamics simulator.
  • Implemented low-level optimisation techniques on the C code, making it run in 1/10th of the original time (~80s to ~7s).
  • Utilised parallelisation by applying multi-threading using OpenMP, and vectorisation using SSE Intrinsics. Made the code parralilsable by removing inter-loop dependencies.
  • Applied general optimisation techniques such as loop unrolling, loop fusion & fission, precomputing static conditionals, and removing unexecuted code.
  • Utilised timers to assess the impact of my optimisations for each significant portion of the program.

    • C

    PLM Parser and Evaluator (Year 2)

    Formal Languages coursework, involving the implementation of a parser and evaluator for a made-up programming language (PLM - Programming Language of the Moment).
  • Distilled the rules of the language into a Formal Grammar (the language allowed functions, parameters, variables, basic mathematical operators and positive integers).
  • Implemented a parser for input programs in the language using JavaCC.
  • Implemented an evaluator for input programs in the language using Java, which first parses the input program then computes the returned result.
  • Obtained full marks for my implementation.

    • Java

    Packet Sniffer (Year 2)

    Operating Systems coursework, involving the implementation of packet sniffer to detect SYN Flood, ARP Poisoning and URL Blacklist attacks.
  • Low-level C implementation of IP and TCP packet header parsing.
  • Multi-threaded implementation to handle high load of incoming packets.
  • Utilised a work queue and mutex locks for the multi-threading to handle high loads and prevent race conditions.

    • C

    Propositional Logic Prover (Year 2)

    Logic coursework, involving the implementation of a logical evaluator to determine whether an input logical theorem is a tautology.
  • Implemented the Resolution algorithm for propositional logic formulas to determine if a given formula is a tautology in a divide-and-conquer fashion.
  • Used Prolog for the implementation, making it entirely functional.

    • Prolog
    Card image cap

    Witter (Year 1)

    Java Programming coursework, involving implementing the backend data store for a "Witter" application (akin to Twitter).
  • Raw implementation of hash tables, search trees and other data structures.
  • Complexity optimisation and balancing between time and space complexities, for scalability.

    • Java
    Card image cap

    Pong (Year 1)

    C Programming coursework, involving implementing the classic "Pong" game on the screen of an oscilloscope via an ARM controller.
  • Primitive game logic, such as game loops and rendering.
  • Extensive report detailing and evaluating our result.
  • Implementation involved creating an API between the oscilloscope screen and the C code, which provided a set of primitive operations such as drawing rectangles and other shapes, which were later combined to form the whole game.
  • Worked with a partner, involving careful planning and collaboration.

    • C
    Card image cap

    Scratch Clone (Year 1)

    Haskell Programming coursework, involving implementing an interpreter to compute the resulting memory state, from an input program in Scratch block format and the initial memory state.
  • Implementation is elegant and idiomatic, harnessing Haskell's powerful abstractions.
  • Implementation utilised a Monad Transformer, after extensive refactoring.
  • Obtained full marks for the implementation, and awarded two Purple λ awards for achieving marks among the year's highest for Functional Programming.

    • Haskell