Fig. 1.4 How a reward updates an action valueIllustrative data
Value the legal actions With ace–king suited in this example state, the network scores Fold, Call, and Raise.
Explore with a call During training, epsilon-greedy exploration can sample a legal action such as Call.
Exploit with a raise On a separate example hand with the same state, greedy play picks Raise, the highest scoring legal action.
Observe the terminal reward Suppose the raise loses 3 big blinds. At the end of the hand the learner can use that result to train on its decisions.
Update an action value The example value of Raise falls, so Call now scores higher in this state. These scores are synthetic and a single update says little about training progress.
During training, the agent sometimes explores another legal move. The hand’s final reward trains its action values. The example scores and reward are synthetic.
Objective. Compare tree search and learning agents on the same four-player Catan deals.
Result. Tree search won 36.3% [31.7, 41.1] on 416 shared deals against three heuristic bots; no learner beat the heuristic baseline. Private-source results, not re-run here.
Fig. 1.5 How tree search picks a moveIllustrative data
List legal moves In this sample turn, the root can build a road, trade with the bank, or end the turn.
Re-deal hidden cards Each simulation samples hands consistent with what the acting player knows.
Expand the search tree The search tries the heuristic move first. It opens more legal branches as visits accumulate.
Play ahead and score After expansion, the heuristic plays ahead for up to two turns. The position score updates the visited branch.
Build the road The search chooses the root move with the most visits. In this example, the road has 5, the trade 3, and ending the turn 2.
The engine samples hidden cards, expands legal branches, scores heuristic playouts and picks the root move with the most visits. Visit counts are illustrative.
Fig. 1.1 How a pixel moves through the filterIllustrative data
Pixel enters the filter The HDMI output stream reads an RGB pixel from the frame buffer. The filter converts it to luma.
Line buffers supply neighbours Three buffers rotate every pixel in this implementation. That rotation spreads the effective taps over four video lines.
Sobel weights combine the taps Six taps contribute to the Y gradient in the recorded impulse response. The X gradient uses its own six taps.
Magnitude combines X and Y The magnitude path squares and sums the wrapped 8-bit gradients and feeds the result to the square-root logic.
Output pixel goes to HDMI The selected result becomes an 8-bit grayscale output pixel. The sequence shows data flow with conceptual timing.
Luma passes through buffers, convolution and magnitude logic to HDMI. The implemented Sobel Y filter reaches across four lines. Timing is conceptual.
Illustration From buttons to a game frameIllustrative data
Read the controls The direction controls supply the player’s input for the game update.
Advance the game Game logic updates the bird, columns and other state at the design’s game ticks.
Check the interactions Gaps, collisions and hearts affect score and lives according to the game state.
Draw the next picture The rendering step turns state into pixels. The browser version is a validated software port; board behaviour remains unverified.
Conceptual game-loop sequence for the Verilog design and its software port. The picture is illustrative, not an RTL trace or a hardware measurement.
Bug Poker
Real-time multiplayer bluffing game with atomic moves and hidden hands. Rules-engine tests; clients and host are trusted.
Illustration From examples to a predictionIllustrative data
Supply example data An implemented algorithm receives features and, for supervised learning, target values.
Fit the model The fitting step estimates the parameters or structure appropriate to that algorithm.
Supply a new input The fitted model can be applied to an input that was not one of the examples.
Inspect its prediction Examples demonstrate usage; this sequence makes no claim about measured predictive accuracy.
Representative use of a fitted model, not a shared API promised by every algorithm. The library is in progress and test coverage is partial.
(a) Systems: latency histogramIllustrative data
(b) Quant: Monte Carlo convergenceIllustrative data
Figure 1. One signature figure per track: (a) per-operation latency for the order book with p50 and p99 marked; (b) a Monte Carlo call price converging on the Black–Scholes value (S = K = 100, r = 5%, σ = 20%, T = 1) inside a 95% band. All panels are illustrative data: they show what each case study will report, not results.Project archive · 16 entries
Table 1. Archive: the 16 existing projects, grouped by track rather than A–Z. tbc marks a year still to be confirmed; the CVs or the commit history give years for 13 of these 16.
Year
Project
Track
Built with
Links
2024
Orderbook Simulation Order matching and VWAP in C++, a from-scratch neural network for price prediction, Python GUIs.How it worksIllustration How a market order changes the bookIllustrative data
Opening book Bids: 12 at 99. Asks: 15 at 102.
Limit sell: 8 at 101 Bids: 12 at 99. Asks: 8 at 101, 15 at 102.
Market buy: 12 Filled 8 from ask 101 and 4 from ask 102. Bids: 12 at 99. Asks: 11 at 102.
Limit buy: 6 at 100 Bids: 6 at 100, 12 at 99. Asks: 11 at 102.
Cancel sell at 102 Bids: 6 at 100, 12 at 99. Asks: empty.
Limit orders add depth. A market buy takes the cheapest asks first, and cancellation removes remaining depth. Trace from the Lab engine.
Arbitrage Finder Checks betting odds for a genuine arbitrage using implied probabilities.How it worksIllustration How the implied-probability check worksIllustrative data
Enter decimal odds In this example, the two mutually exclusive outcomes both have decimal odds of 2.20.
Convert to implied probabilities Each reciprocal is approximately 0.455. The calculation is 1 / 2.20 + 1 / 2.20.
Compare the sum with one The sum is approximately 0.909, below one. The tool can then calculate a stake distribution under its assumptions.
Synthetic two-outcome odds, ignoring fees and availability. This explains the calculation; it is not a live opportunity or a guaranteed real-world return.
C++ Machine Learning Library C++ implementations of foundational ML algorithms, with examples and partial test coverage. In progress.How it worksIllustration From examples to a predictionIllustrative data
Supply example data An implemented algorithm receives features and, for supervised learning, target values.
Fit the model The fitting step estimates the parameters or structure appropriate to that algorithm.
Supply a new input The fitted model can be applied to an input that was not one of the examples.
Inspect its prediction Examples demonstrate usage; this sequence makes no claim about measured predictive accuracy.
Representative use of a fitted model, not a shared API promised by every algorithm. The library is in progress and test coverage is partial.
Neural Network Electronics Simulation A from-scratch neural network that models XOR, NAND, MUX, DEMUX, adder and flip-flop circuits.How it worksIllustration How a network learns a circuit’s truth tableIllustrative data
Supply a truth-table example For XOR, inputs 1 and 0 have target output 1. The project also models other electronic circuits.
Propagate through the network Weighted connections carry the input forwards to a predicted output.
Compare prediction and target The difference between the prediction and the target supplies an error signal.
Update the connections Training adjusts the weights before the next example. This sequence does not claim that training has converged.
Conceptual XOR training example. The topology and values are illustrative; no measured accuracy or convergence is implied.
Four In A Row AI Four-in-a-row opponent using minimax search with alpha–beta pruning.How it worksIllustration How minimax avoids a weak moveIllustrative data
Try legal moves Each root branch stands for a candidate column, followed by possible opponent replies.
Allow for the opponent’s best reply Branch A has replies scored 3 and 5. Its worst-case value for us is 3.
Prune a weaker branch Branch B already has a reply scored 2. It cannot beat the known value of 3, so its remaining reply need not be searched.
Choose the best worst case Branch C has value 1. Branch A’s value of 3 is the best guarantee in this teaching example.
A small synthetic search tree illustrates minimax and alpha–beta pruning. Scores are teaching values, not measured strengths or actual game evaluations.
Flask Rowing App Logs rowing splits and predicts average speed from past sessions.How it worksIllustration From a rowing session to a historyIllustrative data
Record the session A rower logs their session splits in the web app.
Build a session history Stored sessions make it possible to review previous rowing performance.
Review history and estimates The app presents rowing history and an average-speed estimate; this diagram does not establish forecast quality.
A conceptual flow through the Flask rowing app. No athlete data or measured prediction error is shown.
ML · Software
Python, Flask
2023
Zybo FPGA Video Processing Edge filters with Prewitt and Sobel weights on live camera video, in hand-written Verilog.How it worksIllustration How a pixel moves through the filterIllustrative data
Pixel enters the filter The HDMI output stream reads an RGB pixel from the frame buffer. The filter converts it to luma.
Line buffers supply neighbours Three buffers rotate every pixel in this implementation. That rotation spreads the effective taps over four video lines.
Sobel weights combine the taps Six taps contribute to the Y gradient in the recorded impulse response. The X gradient uses its own six taps.
Magnitude combines X and Y The magnitude path squares and sums the wrapped 8-bit gradients and feeds the result to the square-root logic.
Output pixel goes to HDMI The selected result becomes an 8-bit grayscale output pixel. The sequence shows data flow with conceptual timing.
Luma passes through buffers, convolution and magnitude logic to HDMI. The implemented Sobel Y filter reaches across four lines. Timing is conceptual.
STM32L432KC Microcontroller Emulator An educational microcontroller emulator for Warwick engineering students, with a shared C# assembly-text interpreter, 229 integer/DSP/FPU source mnemonics, and an editable browser lab for registers, calls, GPIO, timers and explicit waits. Instruction results have independent reference checks; complete or cycle-accurate hardware emulation is not claimed.How it worksIllustration From an instruction to visible stateIllustrative data
Read an instruction or input The software receives an instruction or an interaction from its simulated controls.
Interpret the supported action The emulator determines the state change for the instruction or addressing mode it supports.
Update registers and memory The software changes the relevant register or memory values.
Show the updated I/O Registers, GPIO, LEDs and other supported controls make the state visible to the learner.
A conceptual emulator cycle for learning registers and I/O. It is not a claim of cycle-accurate STM32 hardware emulation.
Low-Cost Smart Agricultural Sensing System Soil sensing for small-scale rice farmers in South Asia, with a decision tree and a companion app.How it worksIllustration From soil sensing to a useful displayIllustrative data
Read the soil sensor The sensing device provides soil measurements for the prototype.
Transmit the reading A radio link carries the reading towards the central hub.
Process it at the hub The hub supports processing and the project’s data-analysis work.
Present the information A GUI and companion-app work make the information available to the user.
Conceptual data flow from the group project. The sensor could not be independently calibrated within the project budget; no field-accuracy claim is made.
Modular heat exchanger and CAD classes PID control with an industry partner; introductory CAD teaching for first-years.How it worksIllustration How a feedback controller closes the loopIllustrative data
Choose a target The desired operating point supplies a reference for the controller.
Compare and correct A PID controller acts on the difference between the target and the feedback measurement.
Apply the control input The drive changes the process being controlled.
Feed the measurement back The next measurement returns to the controller so it can correct the remaining error.
An illustrative control loop for the PID design work, not a measured heat-exchanger response. The archive entry also covers introductory CAD teaching.
Great Child Nursery Website Freelance site with a client control panel, an enquiry API and caching to cut database calls.How it worksIllustration From nursery information to an enquiryIllustrative data
Prepare the page content The client control panel supports keeping the nursery information up to date.
Read the nursery information Visitors browse the public pages; client-side caching reduces repeated database reads.
Send an enquiry The contact workflow passes an enquiry to the Go API. No real message is used in this illustration.
A conceptual visitor journey through the React site and its enquiry API. This does not expose the private implementation or customer messages.
JobMouse Co-developed job-application tracker with CV and cover-letter tools and application analytics.How it worksIllustration From an application to a useful overviewIllustrative data
Record an application Save the role and company so an application has one place to be tracked.
Keep its stage current Update the application as it moves through the hiring process.
Review the overview The recorded applications support history and analytics alongside the CV and cover-letter tools.
A conceptual application-tracking workflow in the co-developed app. No real applicant records or production metrics are shown.
Discord Bot Music, word filtering, a guessing game and the obligatory ping–pong.How it worksIllustration From a message to a bot responseIllustrative data
Receive a message The bot receives a command or message event from Discord.
Choose a handler The command selects behaviour such as music control, word filtering or a simple game.
Run the selected behaviour The handler carries out the requested bot action.
Return the response A reply or supported Discord action completes the interaction.
Illustrative command routing for the archived bot. The example uses no Discord messages, accounts or live traffic.
Software
Discord API
2022
Paddle-and-Ball Game on an FPGA A paddle-and-ball game in hand-written Verilog for a Nexys 4 DDR board: one button-controlled paddle against a computer paddle that follows the ball, drawn over VGA with a score for each side. Built as practice before an FPGA game coursework project that is not published.How it worksIllustration How the paddles and ball updateIllustrative data
Read the player buttons The buttons move the player-controlled paddle.
Move the ball The ball advances across the field while the computer paddle follows its vertical position.
Check the boundaries Wall and paddle interactions determine how play continues.
Render the game state VGA output displays the paddles, ball and scores for the next picture.
Illustrative frame updates for the single-player Verilog game. The computer paddle follows the ball; no hardware timing or benchmark is shown.
Wingy Wallow Verilog FPGA game with a playable C++/WebAssembly port checked against RTL simulation. Board behaviour remains unverified.How it worksIllustration From buttons to a game frameIllustrative data
Read the controls The direction controls supply the player’s input for the game update.
Advance the game Game logic updates the bird, columns and other state at the design’s game ticks.
Check the interactions Gaps, collisions and hearts affect score and lives according to the game state.
Draw the next picture The rendering step turns state into pixels. The browser version is a validated software port; board behaviour remains unverified.
Conceptual game-loop sequence for the Verilog design and its software port. The picture is illustrative, not an RTL trace or a hardware measurement.
Bug Poker Real-time multiplayer bluffing game with atomic moves and hidden hands. Rules-engine tests; clients and host are trusted.How it worksIllustration How one move reaches the whole roomIllustrative data
Choose a legal move The acting player chooses an action using the state their browser is allowed to read.
Build the update The pure rules module produces the database writes for that move, or refuses an illegal action.
Commit the move once The room’s version must rise by exactly one, so two moves based on the same version cannot both land.
Update the other screens Browsers watching the room redraw from the committed state. Private hands are read separately from the shared table.
An illustrative room update, not a real hand or network trace. Each move is one versioned atomic update; the app still trusts its clients and host.
Arcade: Snake, Block Stacker, Space Raiders, Coding NinjaProductionGame loops, collision and state transitions, with start, pause and restart in every game.
Order book demoLive demoThe C++ order book compiled to WebAssembly: place and cancel orders and watch them match, in the browser.
Poker demoLive demoThe hold’em engine and a trained agent compiled to WebAssembly: play hands against three copies of it, in the browser.
Edge filter demoLive demoThe FPGA edge filter’s bit-accurate model in JavaScript: its Sobel and Prewitt modes and the textbook filters on sample pictures, in the browser.
Zybo FPGA filter playgroundLive demoTry ten Verilog coursework filters on looping video samples, from colour and brightness effects to blur, sharpening and edge detection.
STM32 microcontroller labLive demoStep through an editable ARM assembly program in WebAssembly; inspect integer, DSP and floating-point state, control GPIO/timers, and explore calls and explicit waits.
Option pricing demoLive demoThe C++ Black–Scholes library compiled to WebAssembly: prices, Greeks, implied volatility and Monte Carlo beside the closed form, in the browser.
Wingy WallowLive demoMy FPGA game as a software port of its Verilog, compiled to WebAssembly and checked frame for frame against a simulation of the original: play it in the browser.
Catan AILive demoMy Catan engine and its hand-written and search players compiled to WebAssembly: play a four-player game against three of them, in the browser.
Bug PokerSeparate appMy bluffing card game for two to six friends in rooms of their own, each with a hand only they see and every move shown live; it runs as its own app, linked from the Lab.
5 About and proof
I work across backend systems, search infrastructure, performance-focused development and quantitative finance projects. I trained as an electrical and electronic engineer at Warwick, which is where FPGAs and microcontrollers taught me to count cycles. Away from a keyboard: basketball, cycling, and more home automation than strictly necessary.