whatdidi - command line history search tool

View project on GitHub

A command-line utility that helps you find commands you've previously run. Searches your shell history (both persistent and current session) and retrieves matching commands based on a search term.

• Compatible with bash and zsh, MacOS and Linux.
• Update and uninstall functionality.
• Comprehensive & automated testing suite.
• Persistent user settings for default count and unique results.

Features / Example Usage

Search for the last command you ran:

whatdidi curl
> curl -s https://sh.rustup.rs | sh

Search for the last n commands you ran:

whatdidi mvn 3
> mvn clean compile
> mvn test
> mvn clean compile exec:java "-Dexec.mainClass=simulator.ui.UserCLI"

Supports compound commands (e.g. search for git push specifically):

whatdidi "git push" 2
> git push
> git push -u origin main:refactoring

Supports commands prefixed with sudo:

whatdidi rm 2
> rm foo.txt
> sudo rm bar.txt

Return only unique results with -u / --unique:

whatdidi -u git
> git push origin main
> git commit -m "feat: performance testing framework"
> git status

Set the default result count:

whatdidi --set-default-count 3

Make unique results the default:

whatdidi --set-default-unique true

Update to the latest version, or uninstall:

whatdidi --update
whatdidi --uninstall

Custom macOS/Linux setup script

View project on GitHub

A Bash script that sets up a new macOS or Ubuntu/Debian machine with my full development environment and configuration files, in a single command.

• Detects the OS and installs packages with apt on Linux or Homebrew on macOS, translating package names between the two.
• Installs C/C++ compilers and debuggers, Java and Maven, NeoVim (with my config), tmux, and command-line tools such as fzf, ripgrep, fd and bat.
• Generates an SSH key pair if the machine doesn't already have one.
• Creates time-stamped backups of any config files it overwrites, and is safe to re-run.
• Adds custom shell functions, aliases and git helpers (e.g. rebase onto main, squash a branch).
• Shows a persistent progress bar at the bottom of the terminal while it runs.
• Optional install scripts for Haskell, Prolog and Swift.

Usage

git clone https://github.com/AtlasICL/dotfiles ~/dotfiles
bash ~/dotfiles/setup.sh

Granite block allocator

View project on GitHub

A desktop application that optimises how granite blocks are allocated into containers. Given a CSV of block numbers and weights, it fills each container in turn as close to its maximum weight capacity as possible.

• Solves each container as a 0/1 knapsack problem using dynamic programming, vectorised with NumPy.
• Supports an optional maximum number of blocks per container, handled by adding a block-count dimension to the DP.
• Falls back to a greedy algorithm on very large inputs to keep run times short.
• tkinter GUI for loading the CSV, setting the container count, weight limit and block limit, and viewing the results.
• Unit test suite run automatically with GitHub Actions on every push and pull request.
• Packaged as a standalone Windows executable with PyInstaller.

Custom 16-bit CPU with pipelining and interrupts

View project on GitHub

Built a 16-bit RISC-style CPU in the Issie digital-logic simulator, starting from a half adder and finishing with a pipelined processor that handles interrupts and runs assembly programs I wrote for it.

• Built the arithmetic foundations from scratch: full adders, a ripple-carry adder/subtractor and an 8-operation ALU.
• Designed registers, counters, a ROM-driven message writer and a vending-machine state machine derived from Karnaugh maps.
• Designed the datapath's instruction-decode and ALU-control logic from truth tables, and found and fixed bugs in the provided blocks.
• Wrote the next-PC and conditional-branch logic, including signed and unsigned comparisons from the N, Z, C and V flags.
• Wrote 16- and 32-bit shift-and-add multiplication routines in assembly, optimised to branch on the carry flag.
• Analysed the 2-stage pipeline controller and interrupt handling with two interrupt sources.
• Verified every block cycle by cycle against a reference model.

The EEP1 instruction set and reference model were provided by the Imperial College course team; the circuits, logic design and programs are my own work.

Multi-threaded game simulation in Java

View project on GitHub

Multi-threaded card game simulation in Java, with custom cyclic barrier implementation for thread synchronisation.

Full suite of unit tests using the JUnit framework, including a testing report available on the GitHub repo.

Fundamentals of Machine Learning

View project on GitHub

Built a Python-based logistic regression classifier using scikit-learn to classify handwritten digits. Implemented advanced data cleaning, feature selection, and hyperparameter tuning to optimize results.

Implemented dimensionality reduction using techniques such as PCA, t-SNE and UMAP. Discussed the nuances of these techniques for both data visualisation and preprocessing tasks.

Web Player vs AI Battleships game

View project on GitHub

Web-based battleships game. Users place their ships interactively, and battle an AI.
During gameplay, side-by-side boards track both the user's square and the enemy's.

The project was built in Python using the Flask framework.

Custom lift simulator

View project on GitHub

Built a custom lift simulator in Python. Features a GUI and customisable parameters such as lift capacity, number of floors.

The project uses the tkinter library for the GUI.

Electrical Engineering Group Design Project

View report on GitHub

Built a remote-controlled rover capable of detecting infrared signals, measuring frequency, detecting radio signals, and sensing magnetic field polarity.

Designed and implemented a filtering and amplification circuit for infrared signal detection through a phototransistor.

Simulated the design in LT Spice and prototyped the circuit on a breadboard.

Developed and implemented Arduino code to digitally interface with the infrared detection circuit.

Why is Software OS-Specific?

View project on GitHub

A technical presentation, built in LaTeX Beamer and given at the University of Exeter, on why applications like Adobe Photoshop are tied to one operating system, and what developers can do about it.

• Traces OS lock-in to its technical causes: different system call interfaces, and graphics APIs that only run on some platforms (DirectX, Metal, Vulkan, OpenGL).
• Sets out an evaluation framework from both the user's point of view (stability, performance, features, updates) and the developer's (development time, expertise needed, maintenance).
• Applies it to three real-world approaches: translation layers (Wine / Proton), virtualisation and containerisation (Docker, Podman), and Electron.
• Uses published benchmark data (sysbench and AMD STREAM) to compare container and virtual machine performance against native.
• Every claim is cited, with 25 sources in IEEE style, from textbooks and peer-reviewed papers to official documentation.

The conclusion: there is no universal solution. Each approach trades performance, portability and developer effort against each other, and the right choice depends on the workload and the team.