[{"slug":"nimbleprobe","title":"NimbleProbe","category":"security","kind":"agentic red-team simulation","stack":"Python · Containers · Local LLM","summary":"Agentic red-team simulation framework. Run the loop: environment → context → reasoning → action → feedback → report →","problem":"LLM-based security agents can produce plausible plans without grounding those plans in real host state, network context, permissions, installed software, package managers, or cloud metadata.","built":"A containerized lab framework that collects structured telemetry from the operating system, installed software, package managers, cloud metadata endpoints, file permissions, and reachable network services, then uses a local code-oriented LLM to generate investigative plans, choose actions, analyze pivots, and produce remediation reports.","mechanisms":["host and network telemetry","structured context model","local code-oriented LLM planning","action-feedback loop","pivot analysis","remediation report generation"],"edgeCases":["separating observed facts from agent inference","preventing hallucinated host context","keeping actions inside a containerized lab","avoiding public exploit detail exposure","making the final report auditable"],"artifact":"Architecture flow, sanitized run transcript, lab-only demo, remediation report example. No unsafe exploit payloads or real target data.","link":"https://spuz.me/blog/zine/n4753c_h4ck47h0n_2","repoNote":"The artifact walks a sanitized lab run of the agent loop, separating observed host facts from agent inference. No real target data or exploit payloads."},{"slug":"ai-dialogue-mapping-platform","title":"AI Dialogue Mapping Platform","category":"ai","kind":"deployed AI system","stack":"Full-stack · LLM","summary":"Pre-conversation intake and synthesis engine for difficult group discussions.","problem":"Participants enter hard conversations with hidden disagreements about definitions, assumptions, values, and what they think others misunderstand.","built":"A full-stack platform that interviews participants with adaptive LLM prompts, stores answers in structured form, compares participants across shared concepts, and generates a facilitator brief.","mechanisms":["adaptive intake prompts","structured response storage","cross-participant comparison","tension & shared-ground extraction","facilitator brief generation"],"edgeCases":["uneven answer depth","minority views need preservation","synthesis must not flatten disagreement","admin needs usable output fast"],"artifact":"Public demo with anonymized data; private implementation notes."},{"slug":"sanctions-evasion-network-analysis","title":"Sanctions-Evasion Network Analysis","category":"data","kind":"intelligence workflow","stack":"Graph · Analyst UI","summary":"Entity-graph workflow moving from raw relationships to investigative triage.","problem":"Analysts need a path from entity search to suspicious relationships, risk indicators, and a briefing-ready explanation, not disconnected tables.","built":"A workflow connecting entity, trade, and financial relationship data into a graph view organized around investigation steps: search, expand, inspect, triage, summarize.","mechanisms":["entity graph modeling","relationship expansion","path inspection","risk-indicator panel","briefing output"],"edgeCases":["ambiguous entity names","dense graph clutter","false-positive pathways","explainability for reviewers"],"artifact":"Synthetic-data demo to avoid exposing sensitive data."},{"slug":"sequential-game-analysis-infrastructure","title":"Sequential Game Analysis Infrastructure","category":"research","kind":"research engineering","stack":"Rust · Python","summary":"State-space search and visualization tooling for adversarial sequential games.","problem":"Large game trees are impossible to read from raw solver output. Researchers need interpretable views of strategy behavior, outcomes, and policy structure.","built":"Rust/Python infrastructure for state representation, exhaustive search, redundant-computation reduction, evaluation utilities, and visualization across large adversarial environments.","mechanisms":["state encoding","search traversal","memoization / caching","outcome classification","strategy comparison views"],"edgeCases":["state explosion","duplicate states via different paths","hard-to-interpret policy output","visualizing very large trees"],"artifact":"Research writeup plus selected visual outputs."},{"slug":"multilingual-review-classification-system","title":"Multilingual Review Classification System","category":"ai","kind":"applied ML system · multilingual classification · analyst triage","stack":"Python · scikit-learn · TF-IDF · SMOTE · Linear SVM","summary":"Multilingual review classifier for routing noisy social/product text into Homegoods, Beauty, and Other. Expand the card, then open the artifact to inspect the pipeline, metrics, confusion matrix, and public release design →","problem":"Review triage becomes difficult when incoming text is noisy, multilingual, emoji-heavy, and unevenly distributed across categories. The system needed to turn messy Instagram/Reddit-style exports into a reliable classification pipeline: normalize inconsistent fields, preserve useful emoji signal, map labels across datasets, handle class imbalance, and separate Homegoods, Beauty, and Other despite overlap between categories.","built":"A multilingual text classification pipeline for applied review triage. The system standardizes CSV inputs, merges title/body fields, converts emojis into semantic text tokens with emoji.demojize, maps labels into Homegoods / Beauty / Other, vectorizes text with TF-IDF unigrams and bigrams, applies SMOTE for imbalance correction, and trains linear SVM classifiers with stratified evaluation.","mechanisms":["CSV schema normalization","title/body merge into one inference field","emoji.demojize preprocessing","label mapping into Homegoods / Beauty / Other","TF-IDF unigram + bigram features","English + Spanish stopword handling","SMOTE imbalance correction","targeted Beauty-class oversampling","linear SVM classification","stratified train/test evaluation","classification reports and confusion matrices"],"edgeCases":["emoji tokens can carry category signal","Beauty is underrepresented and needs imbalance correction","Homegoods and Other overlap in lifestyle/shopping language","Spanish and Korean variants require schema cleanup","Reddit and Instagram text create platform domain shift","missing titles or bodies need predictable handling","overall accuracy can hide weak minority-class recall","public release excludes raw user data, URLs, handles, and private artifacts"],"artifact":"Native artifact with five linked panels: pipeline, verified metrics, English confusion matrix, synthetic classify_text walkthrough, and public release policy. Verified notebook results include an English 3-class run at 93.18% accuracy over 3,064 test examples with 250,138 TF-IDF features. Per-class F1: Homegoods 0.93, Beauty 0.88, Other 0.95. Spanish 3-class performance was around 78%, with a Spanish Beauty/Other binary run around 85%.","github":"https://github.com/reedyalouh2/multimodal-review-classifier","repoNote":"Private repo contains the GitHub-safe version of the pipeline: preprocessing, training, evaluation, prediction CLI, synthetic sample data, model card, architecture notes, tests, and the native artifact. Raw platform exports, usernames, URLs, private CSVs, trained private artifacts, and proprietary context are excluded."},{"slug":"2048-game-logic-engine","title":"2048 Game Logic Engine","category":"software","kind":"game logic · state transitions","stack":"Java","summary":"Core 2048 mechanics: board tilt, merges, scoring, game-over detection. Play it →","problem":"The game looks simple but merge rules are subtle: a tile can slide, merge, score, and become ineligible for another merge in the same tilt.","built":"Model logic for a 4×4 board: empty-space detection, max-tile detection, valid-move detection, board tilting, merge ordering, and score updates.","mechanisms":["board-state scan","valid-move detection","single-merge-per-tile rule","directional tilt transform","score & terminal-state update"],"edgeCases":["three equal tiles in a row","four equal → two merges","tilt with no board change","full board, no legal moves"],"artifact":"Native artifact with four tabs: an interactive tilt simulator with before/after board previews and merge highlighting, a line-normalized merge engine trace, terminal-state checks (empty space, max tile, available move), and the validation surface.","github":"https://github.com/reedyalouh2/game2048-logic-engine"},{"slug":"deque-data-structure-library","title":"Deque Data Structure Library","category":"software","kind":"data structures","stack":"Java · Generics","summary":"Linked-list and resizing circular-array deques. Push and pop from either end →","problem":"The same abstract deque API can be implemented with very different memory layouts and performance tradeoffs.","built":"Two generic deques, a linked-node version and a resizing circular-array version, with iteration, equality, comparator-based max queries, and a small sound-synthesis app.","mechanisms":["sentinel-based linked structure","circular index arithmetic","geometric resizing","usage-factor shrink policy","iterator / equality"],"edgeCases":["wraparound add/remove","resize preserving order","removing to empty","stale-reference avoidance"],"artifact":"Native artifact with four tabs: live circular-array deque with capacity/head/resize tracking, sentinel-linked-list visualizer, comparator-driven max deque, and a Karplus-Strong synthesis client that uses the deque as a waveform ring buffer.","github":"https://github.com/reedyalouh2/deque-data-structure-library"},{"slug":"ngordnet-linguistic-analytics-engine","title":"NGordnet Linguistic Analytics Engine","category":"data","kind":"time series + graph backend","stack":"Java","summary":"Word-frequency time series fused with semantic graph traversal. Expand a synset →","problem":"Historical word usage and semantic relationships are separate data problems: one a time series, one a graph.","built":"A Java backend that parses NGram data, represents word histories over time, models WordNet synsets / hyponyms as a directed graph, and answers queries through backend handlers.","mechanisms":["time-series parsing","year-count aggregation","WordNet graph construction","hyponym traversal","query handler design"],"edgeCases":["words with missing years","multiple synsets per word","duplicate hyponyms","filter by usage frequency"],"artifact":"Native artifact with five panels: query pipeline, NGram time-series chart, WordNet graph traversal with multi-word intersection, usage-ranked results, and validation/complexity notes, all driven by synthetic in-browser data.","github":"https://github.com/reedyalouh2/ngordnet-analytics-engine"},{"slug":"procedural-world-generation-engine","title":"Procedural World Generation Engine","category":"software","kind":"game systems · large codebase","stack":"Java","summary":"Seeded tile-world generator. Reroll the seed, watch a new world build →","problem":"A generated world should vary across seeds yet be exactly reproducible for the same seed.","built":"A tile-world engine with seeded randomness, room placement, hallway connection, wall/floor rendering, avatar movement, an interaction loop, and save/load.","mechanisms":["seeded RNG","room generation","hallway connectivity","tile rendering","input loop","save / load state"],"edgeCases":["overlapping rooms","disconnected rooms","thin hallways","invalid movement","reloading exact state"],"artifact":"Native artifact with five panels: live seeded world map with line-of-sight, generation pipeline, room-connectivity graph, scriptable movement/save-state replay, and validation/complexity notes.","github":"https://github.com/reedyalouh2/procedural-world-engine"},{"slug":"hog-strategy-simulator","title":"Hog Strategy Simulator","category":"ai","kind":"simulation · decision strategy · higher-order functions","stack":"Python · Monte Carlo · Higher-Order Functions","summary":"Two-player dice game with Sow Sad, Boar Brawl, and Sus Fuss rules. Expand the card, then open the artifact to roll dice, sweep strategies, and trace exactly when each rule fires →","problem":"A game strategy must choose actions under probabilistic scoring rules (Sow Sad collapses a turn to 1 if any die rolls a 1), positional triggers (Boar Brawl scores 3·|tens(opp) − ones(player)| when rolling 0 dice), and number-theoretic bonuses (Sus Fuss jumps your score to the next prime if it has exactly 3 or 4 factors). The interaction between these rules creates non-obvious sweet spots that a naive strategy misses.","built":"A Python simulator with dice abstractions (fair + deterministic test dice), turn mechanics with full Sow Sad / Boar Brawl / Sus Fuss handling, higher-order strategy functions (always_roll, catch_up, boar_strategy, sus_strategy, a combined final_strategy), make_averaged for *args-based Monte Carlo evaluation, max_scoring_num_rolls sweeps, win-rate comparisons across strategies, and a full game loop alternating turns until the goal.","mechanisms":["dice abstraction via zero-arg functions","Sow Sad collapse on any 1-roll","Boar Brawl positional payoff with min=1","Sus Fuss prime jump via factor counting","higher-order strategy returning n dice","make_averaged with *args for Monte Carlo","goal-aware turn alternation","strategy composition for the final agent"],"edgeCases":["zero-dice turn invokes Boar Brawl, not roll_dice","Boar Brawl with equal tens/ones digits returns 1, not 0","scores below 10 have tens digit 0","Sus Fuss must use exactly 3 or 4 factors (not ≥3)","Sus Fuss only fires once per turn, the prime it jumps to is itself prime","catch_up reads opponent score every call","deterministic test dice cycle for reproducible unit tests","game ends the moment a player reaches goal, no over-shoot mid-turn"],"artifact":"Native artifact with five linked panels: (1) a dice roller that shows Sow Sad collapses live, (2) the full Boar Brawl heatmap colored by payoff with the diagonal min=1 band, (3) every Sus Fuss trigger from 1 to 100 with the prime jump destination, (4) the boar+sus combo lookup that finds the +36 sweet spot at player=91, and (5) Monte Carlo win-rate comparison across the seven strategies with live games-played count. Numbers match a reference Python implementation: always_roll(3)≈0.36, boar≈0.67, sus≈0.68, final≈0.69 win rate vs always_roll(6) under sus_update.","github":"https://github.com/reedyalouh2/hog-strategy-simulator","repoNote":"Private repo contains the full Python simulator (dice, rules, strategies, experiment harness), strategy writeups, and the native portfolio artifact. Win rates and expected turn scores in the artifact are verified against Monte Carlo runs of the same Python code."},{"slug":"typing-autocorrect-and-wpm-tool","title":"Typing Autocorrect & WPM Tool","category":"software","kind":"text processing · UX logic","stack":"Python","summary":"Typing test with accuracy, speed, autocorrect. Type into it →","problem":"Typing tools must measure human input accurately while correcting near-miss words without overcorrecting unrelated text.","built":"Typing-speed and autocorrect logic: paragraph selection, accuracy measurement, WPM calculation, diff functions, correction limits, multiplayer progress reports.","mechanisms":["string tokenization","accuracy / WPM metrics","recursive diff functions","autocorrect thresholds","progress reporting"],"edgeCases":["punctuation & casing","extra or missing words","edit limit exceeded","ties between candidates"],"artifact":"Typing demo screenshot and diff-function diagram."},{"slug":"ants-tower-defense-engine","title":"Ants Tower Defense Engine","category":"software","kind":"object-oriented game system","stack":"Python · OOP","summary":"Tower-defense logic from interacting classes. Place ants, watch targeting →","problem":"Game behavior emerges from many interacting object types: places, tunnels, insects, resources, actions, and win/loss conditions.","built":"Game logic for a tower-defense system: linked places, ants, bees, food generation, targeting rules, specialized ant classes, water/armor behavior, queen logic.","mechanisms":["class hierarchy","turn loop","nearest-target search","resource costs","subclass-specific actions","game-end checks"],"edgeCases":["multiple bees in one place","blocked movement","range-limited attackers","bodyguard interactions"],"artifact":"GUI screenshot, object model diagram, interaction trace."},{"slug":"scheme-interpreter","title":"Scheme Interpreter","category":"systems","kind":"programming languages","stack":"Python","summary":"Interpreter for a Scheme subset. Step source through read·eval·apply →","problem":"An interpreter must convert code into data, evaluate expressions in environments, apply procedures, and handle special forms that don't evaluate normally.","built":"A Scheme interpreter with tokenization/parsing, expression representation, environment frames, eval/apply logic, lambdas, definitions, recursion, built-ins, special forms.","mechanisms":["lexer / parser","Pair / nil representation","environment chain","eval / apply loop","special-form dispatch"],"edgeCases":["lexical scoping","recursive calls","quote semantics","lambda frames","incorrect arity"],"artifact":"Native artifact with four panels: eval/apply trace, environment-frame visualizer, special-form dispatch map, and test surface for reader/evaluator/procedure behavior.","github":"https://github.com/reedyalouh2/scheme-interpreter"},{"slug":"snake-engine-in-c","title":"Snake Engine in C","category":"systems","kind":"C systems · game engine","stack":"C","summary":"Terminal Snake with board parsing and memory-safe ticks. Start the loop →","problem":"A text-grid game in C demands explicit state representation, pointer-safe updates, file parsing, and careful handling of dynamic board data.","built":"A playable Snake engine: board loading, snake init, head/body/tail updates, collision handling, fruit consumption, random placement, state cleanup.","mechanisms":["grid encoding","struct-based state","file parsing","snake traversal","collision / eat logic","memory cleanup"],"edgeCases":["multiple snakes","death on collision","fruit at empty cell","ragged input boards","tail update after eating"],"artifact":"Native artifact with four panels: live tick simulator, C memory model, ragged-board parser, and testing matrix covering movement, collisions, fruit growth, multi-snake handling, and cleanup invariants.","github":"https://github.com/reedyalouh2/snek-engine-c"},{"slug":"risc-v-handwritten-digit-classifier","title":"RISC-V Handwritten Digit Classifier","category":"systems","kind":"assembly · ML systems","stack":"RISC-V asm","summary":"Digit classification at the assembly level. Run the matmul→relu→argmax pipeline →","problem":"A classifier becomes concrete when every matrix load, heap allocation, function call, and arithmetic op is explicit.","built":"A RISC-V assembly classification pipeline: matrix loading, matrix multiplication, ReLU, argmax, file I/O, heap usage, and calling-convention-correct functions.","mechanisms":["RISC-V calling convention","stack / register discipline","matrix multiplication","heap allocation","ReLU","argmax"],"edgeCases":["dimension mismatch","allocation failure","file read errors","register preservation","invalid args"],"artifact":"Native artifact with four panels: full inference pipeline, matmul/dot microtrace, stack/heap register discipline view, and test/error-path map for kernels, binary I/O, allocation, and classification.","github":"https://github.com/reedyalouh2/riscv-neural-classifier"},{"slug":"risc-v-cpu-datapath","title":"RISC-V CPU Datapath","category":"systems","kind":"computer architecture","stack":"Logisim","summary":"CPU datapath executing real RISC-V. Step an instruction through the stages →","problem":"A CPU must coordinate fetch, decode, execute, memory access, and writeback through control signals derived from instruction bits.","built":"A Logisim CPU: program-counter logic, instruction memory, register file, ALU, immediate generation, branch/jump handling, data memory, writeback paths, control logic.","mechanisms":["fetch/decode/execute path","ALU control","register-file wiring","immediate generation","branch/jump selection","memory writeback"],"edgeCases":["branch target calculation","load/store alignment","control-signal conflicts","wrong writeback source"],"artifact":"Circuit screenshot and one-instruction trace."},{"slug":"numc-matrix-library","title":"NumC Matrix Library","category":"systems","kind":"performance engineering","stack":"C · SIMD · OpenMP","summary":"C matrix library with SIMD/OpenMP. Toggle optimizations, watch the speedup →","problem":"Matrix ops are easy to write naively, but performance depends on memory layout, vectorization, parallelism, and algorithmic choices.","built":"A NumPy-style matrix library: C allocation, slicing/reference tracking, basic ops, multiplication, exponentiation, SIMD/OpenMP optimization, benchmarking.","mechanisms":["row-major storage","manual alloc / free","reference counting for slices","SIMD vector ops","outer-loop parallelism","fast exponentiation"],"edgeCases":["invalid dimensions","allocation failure","slice lifetime","non-multiple-of-width loops","power 0/1"],"artifact":"Benchmark chart, memory-layout diagram, optimization notes."},{"slug":"pacman-search-planner","title":"Pacman Search Planner","category":"ai","kind":"graph search · path planning","stack":"Python · DFS · BFS · UCS · A*","summary":"Pacman path-planning over mazes, corners, and food grids. Expand the card, then open the artifact →","problem":"Pacman search is not just moving to a coordinate. Different tasks require different state representations: a single target uses position, corners require remembering which corners have been visited, and food search requires reasoning over the remaining food grid.","built":"Implemented graph-search agents and search problems for Pacman: DFS, BFS, uniform-cost search, A*, position search, corner-collection search, food-search heuristics, closest-dot planning, and maze-distance queries.","mechanisms":["stack / queue / priority-queue frontiers","explored-set graph search","path reconstruction","cost-sensitive UCS","A* priority g(n)+h(n)","corner and food state augmentation"],"edgeCases":["repeated states and cycles","illegal wall transitions","unit-cost vs weighted-cost paths","heuristic admissibility and consistency","large food grids with expensive state spaces"],"artifact":"Deep interactive Pacman search debugger with frontier/expanded/path layers, simple Pacman playback, algorithm comparison, objective switching, cost models, heuristic priorities, and expansion trace. The artifact is intentionally standalone so reviewers can see the end product even without the Berkeley skeleton.","github":"https://github.com/reedyalouh2/pacman-search-planner","repoNote":"Private repo includes source code and the standalone artifact. The artifact exists so the search behavior is visible even without the full Berkeley Pacman skeleton; it uses explicit food pellets so the full search trace remains inspectable and deterministic."},{"slug":"pacman-multi-agent-planner","title":"Pacman Multi-Agent Planner","category":"ai","kind":"adversarial search · game-tree planning","stack":"Python · Minimax · Alpha-Beta · Expectimax","summary":"Multi-agent Pacman planner. Expand the card, then open the artifact to watch the board and tree evolve turn by turn →","problem":"Pacman must choose actions while ghosts also move. The correct decision rule changes depending on whether ghosts are adversarial minimizers, stochastic agents, or scared targets that should be pursued.","built":"Implemented reflex evaluation, minimax, alpha-beta pruning, expectimax, and a feature-based state evaluation function for multi-agent Pacman states.","mechanisms":["reflex successor evaluation","multi-agent minimax recursion","alpha-beta pruning","expectimax chance nodes","depth cycling across Pacman and ghosts","food/capsule/ghost feature scoring"],"edgeCases":["multiple ghosts","depth increments only after all agents move","terminal win/loss states","scared vs active ghost behavior","STOP action penalties","alpha-beta cutoffs without changing minimax value"],"artifact":"Native TSX multi-turn simulator with moving Pacman/ghost board, recomputed decision tree each turn, root-action values that change with the board, minimax/alpha-beta/expectimax modes, evaluation breakdown, optional trace details, and full-screen mode. Hidden until + more → artifact.","github":"https://github.com/reedyalouh2/multi-agent-search","repoNote":"Private repo includes source code and the native artifact. The artifact makes the multi-agent search behavior visible without requiring the full Berkeley Pacman skeleton."},{"slug":"reinforcement-learning-agents","title":"Reinforcement Learning Agents","category":"ai","kind":"MDPs · RL","stack":"Python · Value Iteration · Q-Learning","summary":"Value iteration and Q-learning on the Russell-Norvig BookGrid. Expand the card, then open the artifact to step Bellman sweeps, train Q episodes, and inspect the Q-table →","problem":"Some agents can plan from a known MDP using Bellman backups; others must learn Q-values from experience under noisy transitions, exploration vs exploitation tradeoffs, and unseen state-action pairs. The Berkeley Pacman/Gridworld skeleton is not bundled here, so the portfolio needs a faithful standalone artifact that reproduces the same numerical mechanics on a canonical MDP.","built":"Value-iteration and Q-learning agents for CS188-style MDPs: batch Bellman backups, Q-value computation from V, greedy policy extraction, epsilon-greedy exploration, sample-based temporal-difference learning, approximate Q-learning with feature weights, and analysis-question parameter shaping (discount, noise, living reward).","mechanisms":["batch Bellman value backups","Q(s,a) from V via expected one-step lookahead","greedy policy extraction with tie-breaking","epsilon-greedy action selection","temporal-difference Q update Q←(1-α)Q+α(r+γ·max Q')","feature-weighted approximate Q-values","noise-model transition sampling"],"edgeCases":["terminal states with no legal actions","unseen state-action pairs default to 0","tie-breaking between equal Q-values","discount / noise / living-reward shape policy direction","exploration vs exploitation tradeoff at low ε","feature scaling for approximate Q-learning","Q-learning convergence vs value-iteration ground truth"],"artifact":"Native artifact reproducing the Berkeley Project 3 mechanics on the Russell-Norvig 4×3 BookGrid: step Bellman sweeps and watch V propagate from the +1 terminal outward, train Q-learning episodes with a live agent trajectory, inspect the full Q-table per state, compare the learned Q-policy against the value-iteration ground truth, and shape the policy via discount/noise/living-reward sliders that mirror analysis.py. Numbers match a reference Python implementation to within rounding.","github":"https://github.com/reedyalouh2/reinforcement-learning-agents","repoNote":"Private repo contains the Berkeley Project 3 implementation files (valueIterationAgents.py, qlearningAgents.py, analysis.py) and the standalone artifact. The embedded artifact is a faithful reproduction so the algorithmic behavior is inspectable even without the Berkeley Pacman/Gridworld skeleton; its V and Q values have been verified to match a reference Python implementation of the same mechanics."},{"slug":"probabilistic-ghost-tracking","title":"Probabilistic Ghost Tracking","category":"ai","kind":"Bayes nets · HMM inference","stack":"Python","summary":"Belief tracking from noisy sensors. Observe a reading, watch the posterior update →","problem":"Pacman can't directly observe ghost locations, so it must maintain and update beliefs under sensor noise and movement uncertainty.","built":"Inference agents using Bayes nets, variable elimination, exact inference over time, and particle filtering for one or more moving hidden ghosts.","mechanisms":["factor operations","variable elimination","belief distribution updates","time-elapse model","observation update","particle resampling"],"edgeCases":["zero-weight particles","jail position","multiple ghosts","normalization","noisy likelihoods"],"artifact":"Exact-vs-particle posterior visualization, animated noisy-sensor belief update, and inference-flow card. Full course solution code kept private.","github":"https://github.com/reedyalouh2/probabilistic-ghost-tracking","repoNote":"Private repo contains artifact, explanation, and attribution only. Full solution code kept private."},{"slug":"neural-models-for-classification","title":"Neural Models for Classification","category":"ai","kind":"machine learning","stack":"PyTorch","summary":"Train curves for digit ID, language ID, CNNs, attention. Run training →","problem":"Different supervised tasks require different architectures, losses, and input representations.","built":"Neural models trained for digit classification, language identification, convolutional image recognition, attention-based prediction, and character-level modeling.","mechanisms":["training loop","loss functions","linear layers","CNN feature extraction","attention weights","validation metrics"],"edgeCases":["overfitting","class imbalance","learning-rate sensitivity","sequence length variation","misclassified examples"],"artifact":"Model smoke tests, regression training curve, predicted-vs-true function approximation, attention probe, and manual convolution probe. Full course solution code kept private.","github":"https://github.com/reedyalouh2/neural-models","repoNote":"Private repo contains artifact and technical writeup. Full training/source code kept private."},{"slug":"memory-safety-exploitation-lab","title":"Memory Safety Exploitation Lab","category":"security","kind":"binary exploitation · stack internals","stack":"C · x86 · GDB","summary":"Seven classic memory-corruption classes on 32-bit x86, each defeated in a lab and mapped to the mitigation that stops it. Expand the card, then open the artifact to watch the stack overflow, the canary catch, and step through every technique →","problem":"Unsafe memory operations corrupt stack and control data and create exploitable control-flow behavior. Each mitigation introduced to stop one technique (length checks, stack canaries, address randomization, input transforms) carries its own bypass, and understanding why requires seeing the stack at the byte level, not just reading about it.","built":"A structured study of seven vulnerability classes, plain overflow, signed-length bypass, canary leak-and-replay, off-by-one frame-pointer corruption, input-transform-aware overflow, format-string write primitive, and info-leak + canary + libc, each analyzed in a debugger, exploited in an isolated lab, and mapped to the modern defense that closes it.","mechanisms":["32-bit x86 stack-frame analysis in GDB","buffer overflow reaching the saved return address","signed vs unsigned length-check confusion","stack canary leak and verbatim replay","off-by-one saved-frame-pointer corruption","format-string %hn write primitive","info-leak-driven ASLR defeat","mapping each technique to its mitigation"],"edgeCases":["little-endian address byte order","one-byte SFP overwrite is a full control primitive","reversible input transforms add no security","canaries fail the moment they're observable","ASLR collapses on a single address leak","layered defenses because each one alone has a bypass"],"artifact":"Native artifact with four panels: (1) a live stack visualizer where you fire an overflow and watch bytes climb from the buffer into the saved frame pointer and return address, (2) a stack-canary demo showing the guard catching a naive overflow then being defeated by a leak-and-replay, (3) a step-through of all seven challenges with their stack layouts and conceptual payload shapes, and (4) a mitigation matrix mapping each technique to the defense that stops it. Defense-oriented, no working payloads, no shellcode, no real offsets.","github":"https://github.com/reedyalouh2/memory-safe-exploitation","repoNote":"Private repo contains a defense-oriented writeup, a 32-bit x86 stack primer, a per-challenge walkthrough, and a mitigations reference. Deliberately contains no runnable exploits, target addresses, or shellcode, the value is in understanding why each bug is exploitable and what stops it."},{"slug":"cryptographic-file-sharing-system","title":"Cryptographic File Sharing System","category":"security","kind":"secure storage · applied cryptography","stack":"Go · AES · HMAC · RSA · DSA · Argon2","summary":"End-to-end encrypted file sharing that assumes the server is malicious. Expand the card, then open the artifact to inspect the untrusted datastore, trace the key hierarchy, and watch revocation re-key the file →","problem":"A storage system must keep files confidential and integrity-protected even when the datastore itself is adversarial, free to read, tamper with, reorder, or delete any byte, and when sharing relationships change, including users who must be cryptographically locked out after having had legitimate access.","built":"A client-side design with no trusted server logic: password-derived key hierarchies, an encrypted per-user file index, per-user-per-file access nodes, a main-file-node indirection layer that makes sharing and revocation tractable, files stored as a backwards linked list for constant-bandwidth appends, public-key-wrapped + digitally-signed invitations, and a revocation path that re-keys the entire file and cascades to sub-sharees.","mechanisms":["Argon2 root key derived from password + username salt","HashKDF subkey separation per object family","encrypt-then-MAC on every stored object","per-page keys derived from file key + page UUID","deterministic UUIDs for index-free access","MFN indirection: one node per direct sharee","public-key-wrapped, DS-signed invitations","revocation re-key with automatic cascade"],"edgeCases":["datastore adversary tampers with any object → integrity check fails, never silent corruption","revoked user retains old keys but they decrypt nothing new","append bandwidth must not scale with file size, file count, or share count","authentication by decryption, no stored password or verifier","overwrite preserves existing share graph","revoke-before-accept, double-share, and non-owner revoke all rejected","sub-sharees ride inviter's MFN so cascade is automatic"],"artifact":"Native artifact with four linked panels: (1) a live view of the untrusted key-value datastore showing every object as ciphertext, (2) an interactive key-hierarchy tree from the Argon2 root down to per-page keys, (3) a step-through of the backwards-linked-list append showing that only one new page is written, and (4) a revocation simulator that re-keys the file and visibly scrambles a revoked user's view while authorized users still read it. The artifact is a faithful structural model of the real implementation.","github":"https://github.com/reedyalouh2/cryptographic-file-sharing","repoNote":"Private repo contains the full Go implementation, integration test suite (correctness, integrity, bandwidth, sharing/revocation), architecture and threat-model docs, and the standalone artifact. The artifact faithfully reproduces the encryption and keying scheme so the security behavior is inspectable without the full course skeleton."},{"slug":"vulnerable-web-server-breach-lab","title":"Vulnerable Web Server Breach Lab","category":"security","kind":"web exploitation · trust boundary analysis","stack":"Web · HTTP · SQL · JavaScript","summary":"Six web-application vulnerabilities across three attack families, SQL injection, XSS, and path traversal. Expand the card, then open the artifact to probe each trust boundary and see the attack fire and the fix engage →","problem":"Web systems fail when user-controlled input crosses a trust boundary without being sanitized: into a SQL query, into HTML, or into a file path. Each of the six flaws here is one missing sanitization step, and together they form a complete escalation chain from unauthenticated attacker to admin access and arbitrary file read.","built":"A controlled analysis of a deliberately vulnerable file-hosting application. Identified and exploited: SQL injection via UNION SELECT for data exfiltration and session hijack, stored XSS via filename to steal session cookies, reflected XSS combined with CSRF to delete files, SQL injection plus MD5 hash cracking for admin escalation, and path traversal to read server-side config files. Each mapped to the precise defensive control that closes it.","mechanisms":["UNION SELECT injects a second query alongside the original","session token lookup injectable via same SQLi surface","filename stored and rendered as HTML without encoding","reflected ?term= parameter executes in victim's browser","cross-origin POST accepted without CSRF token check","MD5 hash extracted and cracked offline in seconds","../config traverses out of the intended file directory"],"edgeCases":["SQL injection via search field reaches a different table than intended","session tokens must be validated for format before reaching the database","stored XSS requires sharing with a target to become a targeted attack","reflected XSS + CSRF fire together from a single crafted URL","MD5 with no salt is trivially reversible for common passwords","path traversal requires only a single ../ to escape the serving directory","parameterized queries alone close three of the six flags"],"artifact":"Native artifact: a request-flow visualizer for each of the six vulnerability classes. Pick an attack, watch the request probe the application layer, see the injection/XSS/traversal fire against the vulnerable state, then toggle the defense, parameterized query, output encoding, CSRF token, Argon2, or path canonicalization, and see it block at the trust boundary. Sanitized; no live credentials or session data.","github":"https://github.com/reedyalouh2/vulnerable-web-server-breach-lab","repoNote":"Private repo contains per-vulnerability writeups, a defense reference mapping each control to the attack step it breaks, and a trust-boundary analysis. No live credentials, tokens, or exploit scripts."},{"slug":"traceroute-implementation","title":"Traceroute Implementation","category":"networks","kind":"packet-level networking","stack":"Python","summary":"Traceroute from scratch. Send probes, watch TTL climb and hops resolve →","problem":"Traceroute must infer hop-by-hop paths from limited ICMP responses while handling timeouts, duplicates, unrelated packets, malformed packets, and loops.","built":"A Python traceroute using increasing-TTL probes, UDP sends, ICMP response parsing, router grouping by distance, and defensive packet validation.","mechanisms":["TTL-controlled probes","raw packet parsing","IPv4 header extraction","ICMP type/code handling","per-hop grouping","timeout logic"],"edgeCases":["duplicate packets","delayed duplicates","invalid ICMP","truncated buffers","silent routers","router loops"],"artifact":"Route diagram, packet-header diagram, edge-case matrix.","github":"https://github.com/reedyalouh2/traceroute-from-scratch","repoNote":"Private repo: the implementation plus byte-level packet-format and edge-case docs. The artifact shows the TTL climb, the nested ICMP packet, and per-probe port matching."},{"slug":"distance-vector-routing-protocol","title":"Distance-Vector Routing Protocol","category":"networks","kind":"distributed routing","stack":"Python","summary":"Router mesh with Bellman-Ford. Cut a link, watch the network reconverge →","problem":"Routers must learn paths from neighbors while avoiding stale routes, loops, and count-to-infinity behavior.","built":"A distance-vector router: static routes, forwarding, advertisements, Bellman-Ford updates, route expiration, split horizon, poison reverse, triggered updates.","mechanisms":["forwarding-table entries","route advertisements","Bellman-Ford update","route TTL expiration","split horizon","poison reverse","triggered updates"],"edgeCases":["link down","route timeout","equal-cost stability","count-to-infinity","poisoned propagation"],"artifact":"Simulator trace, protocol notes, route-table snapshots.","github":"https://github.com/reedyalouh2/distance-vector-routing","repoNote":"Private repo: the router plus algorithm and loop-avoidance docs. The artifact lets you cut a link and watch count-to-infinity happen, then toggle split horizon to prevent it."},{"slug":"tcp-like-reliable-transport-layer","title":"TCP-like Reliable Transport Layer","category":"networks","kind":"transport protocol","stack":"Python","summary":"Reliable delivery over a lossy link. Play the timeline, drop a packet, retransmit →","problem":"Packets can drop, duplicate, reorder, or arrive late, but applications expect ordered byte streams and connection semantics.","built":"A TCP-like transport: connection setup, sequence arithmetic, send/receive windows, ordered delivery, out-of-order buffering, ACK handling, retransmission, state transitions.","mechanisms":["three-way handshake","sequence numbers","sliding windows","ACK processing","out-of-order buffer","retransmission timer","state machine"],"edgeCases":["dropped SYN/ACK","duplicate data","out-of-order arrival","window wrap","FIN / close","retransmit dedup"],"artifact":"Protocol diagram, packet trace, state-machine note.","github":"https://github.com/reedyalouh2/tcp-reliable-transport","repoNote":"Private repo: the socket plus state-machine, sequence-space, and RFC 6298 retransmission docs. The artifact computes the real adaptive RTO live as ACKs arrive."}]