This was just an exercise in C (had to scratch an itch).
I wanted to try writing a very simple syntax parser, so I thought I'd write something that takes syntax commonly used in .txt files and convert it to .html. All the syntax rules are just a subset of Markdown though. I wouldn't use it outside of a learning exercise though, forking cmark would make a lot more sense.
I also took the opportunity to play around with Valgrind and made sure the tool was free from errors and memory leaks using both the musl and GCC compilers!
A two-part project that started a way to learn the Go language.
The first part is suti, which stands for single unified template interface.
It provides a single library (or binary) that can parse any input written in supported data-serialization languages and templating languages.
It uses librarys to parse these files (which do all the complicates stuff), this tool simply provides an interface to all of those libraries
I used this project to try out test-driven development. Go seemed like a perfect fit because of how testing is built into the language.
Currently it supports: mustache, golang templates
for the templating languages and the standard JSON, YAML, TOML for data-serialization. I'm aiming to add more template language support in the future.
The second part is pagr. A static site generator that aims to be really simple to use and to let you layout your project directory however you like.
It uses suti for handling the templates and data files. It's main responsibilities are to parse the user's project files into a data structure to be
loaded by suti and used to execute against loaded template files to produce a static website. In future, I'm hoping to add a few features like enabling RSS feeds.
I use this tool to generate my personal website: gearsix.net
A small Python utility I wrote to help manage my dotfiles. I probably didn't need to add another tool to https://dotfiles.github.io/, but after having a brief look I decided I wanted to write my own.
It currently a little janky, but it's certainly good enough for a v1.0 release of a small utility - especially since I'm probably going to be the only person using it. I'll be slowly improving it as I use it.
As a Lead Developer at AppSecTest (a series-A startup), I worked on a product suite that reverse-engineered mobile games to check for security & legal compliance issues. We offered a cloud solution and on-premises, the latter with installation/setup scripts.
Two Kotlin analysis agents: one for .apk files (Android apps), the other for .ipa files (iOS apps); both reverse-engineered files into a complex data structure and then ran that against against a varying set of detectors which checked for security & legal compliance issues.
A small NodeJS server to handle queuing and transport of files uploaded by users (via the above web-app) and results output by the analysis agents.
A React/Material-UI web-app, which provided users an interface to: upload files for analysis; view, compare and generate HTML reports of analysis results; JIRA issue creation & tracking of said results, email said reports, email feedback, view statistics of platform usage & results data, as well a slew of admin features.
It ran on a NodeJS (express) backend server, which used a PostgreSQL database.
Hosted on two seperate Digital Ocean Kubernetes clusters. One was for staging deployments, only accessible via our internal VPN; the other was for production deployments accessed by our customers.
I was accountable for as lead developeri for the webapp(3.) and file/result transport server(2.) and as the secondi (of two) developers working on the analysis agents(1.) and maintaining our infrastructure (4.). AppSecTest was a 4-man team, so the work was shared.
A lot of my focus at AppSecTest was spent making sure projects were at a professional/enterprise-standard.
Role as lead developer required complete project oversight & management and doing the majority of development work.
Role as secondary developer required me to do a lot of bugfixing and a re-write of the I/O around the core libraries of the analysis agents.
It consists of an embedded C library (designed for generic microcontrollers) for using the Microchip RN2483 LoRa modulei. The library aims to be easily portable; specific platforms are currently supported on separate branches of the git repository.
The second component of this SDK was a lightweight embedded C++ framework for making it really quick & easy to plug Grove Modulesii into an IoT solution. The framework is also designed to be easily portable to any embedded platform; again the master branch of the git is non-platform-specific, with support for different platforms on different branches.
Both of the above were designed for generic microcontrollers. All I/O (which is specific to each platform) was modularised down to a single function to make porting them simple
Of course a dissertation isn't worth much without the paper. I found the research for this quite fun and plan to write a personally-published paper based on it. A link to the paper can be found below.
This was a university project for my Internet of Things module, which I passed in my final year. The goal was to create a Single Wire Protocol that could transmit data between two BBC micro:bit devices across a single wire plugged into one of the GPIO pins on each side. A working demonstration of the protocol was also required.
Designing a protocol was an intresting experience. Having previously implemented the SNTP protocol (according to the RFC), I understood this was an instance where implementation was really secondary to the documentation. In this instance, the implementation was there to test the documentation.
Personally, I'd like to try designing a more complex protocol in the future with better documentation.
The Smart Shelf was an old demonstration of a full-stack IoT solution; in the last few months of my intership at Intel, I re-designed it to showcase LoRa(WAN) - which was a new technology I was assigned to investigating so that we could provide something to customers inquiring about the technology.
This required researching LoRa & the LoRaWAN protocoli; prototyping multiple LoRa devices; justifiying commercial viability; and producing a full prototype.
This project was a really good (slimmed down) insight into the steps required in developing a product; I enjoyed almost every step of it. Justifying commercial viability of the project was a newer type of challenge for me, however I found it actually helped shape how the prototype turned out. The resulting prototype ended up being used as a showcase in the London office and I provided several talks on it before going back to university.
I documentented the majority of my research (for knowledge transfer).
This would have been published as a white-paper, but we ran out of time.
This was another small university project done for the Internet of Things module that I passed in my final year. The goal of this project was to write a game for the BBC micro:bit, this acted as an introduction/refresher in programming on hardware to students.
The game I created is based on Bop It! All you need to do is the action prompted on the matrix LED display within a certain time limit.
By default the actions you're asked to do are: Press A (A), Press B (B), Tilt away from you (↑), Tilt towards you (↓), Tilt left (←), Tilt right (→).
There were more actions that could have been added into the game, however the micro:bit didn't reliably respond to them. I did make it very easy for anyone to modify the actions the game asks you to do (in part thanks to the awesome MicroBit API).
The game continues until you take a wrong action or miss an action, after this happens you're given your score (the number of sucessful actions you made), followed by a little message from the developer.
MicroIMG
A by-product of this project was a small repo that I wrote as a time-saver for displaying images & animations on the 5x5 dot matrix display.
The Lancaster microbit runtime uses MicroBitImage objects to print to micro:bit displays. These objects represent bitmaps and can be of any size (for different displays) as well as individual brightness levels for each LED (note: these objects are a managed type, so memory is managed for you - no need to delete them).
This library contains a bunch of these objects, pre-defined. In the header file you'll find comments documenting what each MicroBitImage object displays on a 5x5 MicroBit LED display.
The animations are a set of functions that use the pre-defined MicroBitImages and a MicroBitDisplay to print animations. These animations are blocking as they set the MicroBit passed to it to sleep between frames, however they're fairly quick and you can queue anything that might happen while the animation is playing (thanks to the wonderful DAL library).
Several of my Computer Science tutors were specialised in Artificial Intelligence and we were subject to several courses on the topic. One of the more intresting ones was in my final year where we studied biocomputation - finding new ways to exploit computation with bio-inspired methods: The natural world has often provided inspiration for solving complex problems
A project we were given in this course was to construct a basic Genetic Algorithm that could help find patterns within provided data sets.
This turned out to be very fun, we were given the chance to do it in any language so I also used it as an opportunity to learn Python. At the time I'd heard about how Python was really popular among data scientists (due to packages such as panda); in the end it's execution was slower than I'd have liked though.
This was a university project in my second year Computer Operating Systems & Networks module (certainly one of the most fun).
The aim was simply to product a working, RFC4330-compliance SNTP server & client with both unicase and multicast addressing modes and prove it works using wireshark.
Doing this was really one of my favorite university projects, since it taught an important lesson in reading & interpreting documentation, as well as an underlying understanding of how network software worksi
