Alexander Collins

Software Engineer
Computer Science Graduate

Technical Portfolio

As any developer that heavily relies on open source projects for their day-to-day, I think it's important to contribute back.

This list is going to get much longer in the future!

This is the website I built to host personal projects and anything I'm interested in enough to write about and share. It's an ever-evolving project where I (generally) focus on the non-enterprise side of software.
A few highlights below:

  • sya - A tool that downloads & splits an audio track from youtube. I initially kept it to myself for podcasts but realised non-technical folk would need GUI it, this gave me the opportunity to learn PyQt.

    The GUI came about because of a fun story in my D&D group, the storyteller would play ambient music tracks in the background and started to get JOIN YOUTUBE PREMIUM TODAY adverts at very dramatic moments (very funny the first few times).


  • tralloc - A library in C that transparently tracks the total amount of allocated memory and the size of individual memory blocks for you.
    To any C developers - it's experimental and relies on unsafe behaviour, so I don't recommend using it in production.

    Links:Tracking Allocations in Ccode

  • Piece Chain - I was researching different text editors and discovered a text buffering algorithm that I really loved: the Piece Chain/Table/etc. This resulted from a rabbit-hole that eventually landed at Niklaus Wirth and his Oberon OS, which was a text-based OS that made heavy use of the algorithm.
    I implemented the algorithm in C, using part of an Oberon paper Wirth had written for reference.


  • shuntyard - An implementation of Djikstras Shunting Yard Algorithm. I found the wikipedia page on it and thought it sounded cool. It uses a stack to convert mathematical expressions written in infix notation to their equivalent in polish notation.


  • More highlights ...
    • Git Server - I setup my own git mirror server on a Raspberry Pi 1 B+ I had lying around. I documented the process so I'd have something to go back on for future reference.
      It updates every 24hrs from more reiable servers (like GitHub) that I push commits to.

    • txt2html - A parser/generator to convert text to a subset of Markdown.
      I wrote this to challenge myself to try writing simple parser/generator for Markdown after a growing curiosity that resulted from writing mdoc (a cli stream interface to cmark).


    • mwim / dati - This is a static site generator which I used as a learning project for the Go language. It It went through several iterations but now I'm happy enough with it to use it for building from Markdown and HTML templates.
      It also gave me a chance to try out Test-Driven Development as Golang has great builtin testing.
      It also gave me a tool to do this.


    • xpm - A shell script that provides a generic interface to the host system package manager.
      It doesn't do anything smart but except providing a single set of commands to the multitude of package managers that all do (roughly) the same thing from a user-perspective.

      Links:project code

    • dotfm - A Python cli tool I wrote out of the frustration of managing my dotfiles. It allows you to install/modify/remove files whenever required using symlinks and set aliases to remember them by. It also knows where the dotfile should be, so you don't need to remember the filepath of it.
      I tend to use this day-to-day, it's great.

      Links:article code

During my final year at university, I joined a series-A startup company named AppSecTest, where I was one of two software engineers in a 5-man running a company the delivered a product which provided an on-premesis & cloud-service solution to decompile & provide static analysis on Android applications, checking for security, legal and privacy compliance.
After five years as a tight, single unit we successfully sold the team & technology to OneTrust in 2022, OneTrust were the largest global data-privacy company in the world at the time. At OneTrust we spent 4-5 months imptegrating our technoogy into their enterprise cloud as a SaaS, spear-heading their move to an AWS-style cloud model. Some of my work during this period:

  • Developed a decompiler for ARSC files (a compressed XML format). This required a lot of time spent bit-fiddling and staring at binary in a hex editor but it was very fun & rewarding.
    • We didn't need to decompile for the entire ARSC specification, so I built the system to be fault-proof: it would recover if it came across an unknown block of data, report it, and move on. This resulted in very quick & easy debugging.
  • Built a network I/O layer into solution, allowing for cloud deployments. This was integral to selling the product and deploying it for demos on our Digital Ocean/Kubernetes infrastructure stack.
  • Developed & maintained two backend NodeJS (express) servers, which communicated with a PostgreSQL database. One of these servers managed a the I/O queue for the analysis engine(s). Another of these servers managed the frontend web application and various services, such as user-management and authentication, data transformation and aggregation, etc.
  • A React/Material-UI web application, which provided users an interface to: upload files, view results, compare results, generate HTML reports, plug-in to JIRA and create issues based on results, etc.
  • I wrote several algorithms on the backend which did interesting things to the results data that we successfully used to pitch our technology. My favorite was certainly the comparison algorithm, which created deltas of elements for multiple analysis results of multiple versions of an individual application.

A full-stack Internet of Things demo, which I initially took over development for from the intern previously in my role. This was my learning experience for gaining knowledge of full-stack IoT development, from the microcontroller upto a server and then to an end-user in a web/android application.
Near the end of my internship, the demo was re-purposed as research project and showcase for the LoRa(WAN) technology.I was able to research LoRa & the LoRaWAN protocol in-depth, prototype and showcase mutliple LoRa devices, justify the re-worked demo design to my team and fully build the demo.
The research was in-depth enough that it went on to form my dissertation.

The demo itself measured item stock on store shelves using infrared distance sensors & the Intel Quark D2000. This data was sent back to a server via a HP edge gateway running a WindRiver system. The data was then displayed to the end-user in an web/android app.

Links: IoT LoRa Quark demoSmart Shelf 2 slideshow

I studied a Computer Science (Honours) degree at the University of the West of England, with an 14-month internship at Intel inbetween my second and final years. During my course we studied several interesting topics, some highlighted modules: Computer & Network Operating System, Artificial Intelligence, Internet of Things, Ethics and Professionalism, Data Structures and Algorithms

  • IoT LoRa(WAN) SDK - In my final year I produced a dissertation that carried on from research I started while doing my internship at Intel: an IoT LoRa(WAN) SDK. It resulted in a C library for microcontrollers to interface with the RN2483 LoRa module and an extendable plug-n-play C++ framework for Seeed Studio Grove sensors.
    Both libraries were designed to be easily ported to multiple microcontrollers, with all non-portable I/O kept to two individual read/write functions.

    The research was the most important part and it allowed me to gain a understanding of LoRa(WAN) v1.0 (from the PHY-APP layers).

    Links: RN2483 libraryGrove Sensor frameworkResearch

  • SNTP Server & Client - This was a for the Computer Network Operating Systems module. The aim was to produce a working, RFC4330-compliant SNTP server & client with unicast and multicast addressing modes and provide working proof with wireshark. The project was written in C using POSIX sockets.
    This project was a very useful lesson in reading & interpreting documentation, since it was my first time reading an RFC.

    Links: source

  • MorseBit Protocol - This one was for the Internet of Things module. The goal was to create a Single Wire Protocol that could transmit data between two devices across a single wire via GPIO pins on either side with a working demonstration on a BBC Micro:Bit.

    Our method of translating Morse Code to digital values that could be sent in a short amount of time was to interpret (based on button-held time) a dot as 0 and a dash as 1; this set of 1's and 0's would be interpreted as a byte which was used as the index of lookup table that translated morse code letter to it's ascii equivalent using a binary tree.
    This way we only had to send (at most) 6 HIGH/LOW signals for any characters in the table.

  • BitIt - A university project that created a game based on Bop It using the BBC Micro:Bit built-in sensors. The idea is the consecutively carry out the actions displayed on the LED matrix animations within a narrowing time window and see what the highest score you can get is. The game's a lot of fun and works quite well on the device.

    I also wrote a small library that helped with displaying animations on the devices LED matrix.

    Links:BitIt sourceMicroIMG source

  • Genetic Algorithm - The Computer Science department of the University had several AI specialists, consequently we had several AI modules. My favorite of these was Biocomputation: The natural world has often provided inspiration for solving complex problems.

    The Genetic Algorithm was a project where we built said algorithm and used it to find patterns of data in provided data sets. I used it as an opportunity to learn Python (since it was the data science language at the time).


  • Motorola 6800 simulator - In our very first year during Computer Network and Operating Systems our professor had us finish off a simulator for the 70s 8-bit Motorola 6800 MCU that was written in C.

    We split into groups and all implemented different parts of the assembly instructions set that was specified in the Programming Reference Manual for the system, which nicely laid out each instruction and exactly what it did. The end result wasn't incredibly complicated but provided a great insight into how assembly systems work (mostly moving bytes between registers).