Projects

A live, role-based platform for capturing and managing soccer match data in real time. Scouts record events pitch-side on a streamlined portal. Admins assign scouts to fixtures, approve requests, manage teams and competitions, and track coverage. Leaderboards and points reward contribution, while expenses and assignments keep operations organized. Built for soccer today and structured to add other sports with minimal changes. Fast UI, clear permissions, and reliable cloud hosting make it practical on match day.

Raft is a consensus algorithm that keeps a cluster of machines in agreement on a sequence of operations. It makes a replicated log behave like a single reliable log, even when some nodes crash or restart.

• Leader election: Nodes start as followers. On timeouts they become candidates, vote, and elect a leader that coordinates the cluster.
• Log replication: The leader appends client commands to its log and replicates them to followers via AppendEntries RPCs until a majority acknowledges.
• Safety & commitment: Entries are committed only when stored on a majority and applied in order to the state machine, guaranteeing linearizable results.

This repository contains my Go implementation with timers, RPC stubs, persistence hooks, and tests to exercise elections and replication under failures.

A simplified Chord overlay network with a central registry and many messenger nodes. Nodes form a structured P2P ring and route messages efficiently using finger tables.

Overview

• Registry ↔ Messengers: messengers register/deregister via short-lived TCP connections; the registry keeps command connections open while awaiting responses.
• Messenger ↔ Messenger: persistent TCP connections for peers in each node's finger table; auto-reconnect on failure for high-volume traffic.

Protocol

Key messages: Registration, Deregistration, NodeRegistry (finger tables), InitiateTask, TaskFinished, RequestTrafficSummary, ReportTrafficSummary.

Run

• Registry: go run registry.go <port>
• Messenger: go run messenger.go <host:port>
• Default setup: ./run_macos.sh 8099 10 25000 (opens N terminals, one per process)

Commands: setup (finger tables), start (send packets), route (show fingers), list (registered), print/exit (messenger).

Logs are written to /logs: one file per messenger plus a registry.log.

This extends Kessels' two‑process algorithm to three independent processes (Alice, Bob, Charlie) so that at most one dog is in the garden at any time. The design uses only private flags (written by a single process, readable by all) and busy‑wait conditions to coordinate entry.

The state is split into two arbitration layers implemented with small two‑bit flag arrays: A and B coordinate Alice/Bob;AB (set by the winner of A/B) arbitrates against Charlie, who uses C. In the A/B layer, each process sets[0] to request and [1] as a tie‑breaker. They wait until either the other has no request or the tie‑breaker says it is safe. The winner then raises AB and competes with Charlie, which mirrors the same two‑flag pattern (AB vs C).

• Mutual exclusion: only one layer winner proceeds to the second layer, and only one of {AB, C}can pass its await condition at a time.
• Deadlock freedom: timeouts/tie‑breakers force progress—if both contend, one flips the tie bit and the await eventually releases a process.
• Starvation freedom: each contender eventually becomes the winner of its layer due to alternating tie‑breakers, so every waiting process gets the garden.

Variables are owned dynamically: each process writes only its own flags (A by Alice, B by Bob, C by Charlie; the winner writes AB) while others read them. This preserves the "private writer" constraint from the assignment while enabling safe coordination for three processes.