The interactive diagram needs JavaScript. The projects are also available as text
below.
Oct 22, 2026 Tooling
Claude Code status line
claude-code-statusbar
Custom status line for Claude Code — a single Node.js script that reads session JSON from stdin and
outputs a formatted ANSI status bar to stdout. Zero dependencies, uses only Node.js built-ins.
Related: Numerical solvers (shared command-line workflow).
Node.js, ANSI, Git, Process Inspection
Case study notes
Overview
A production-grade status line that displays model info, working directory, token usage, context
window percentage, git status, running agent count, and current time — all in a single compact line.
Architecture
Single-file executable (index.js) with modular helper functions: ANSI color utilities, safe
property accessors, token formatting, safe shell execution with timeouts, and a main stdin handler
that parses session JSON and builds 7 segments joined by dim separators.
Decisions
Zero dependencies — only Node.js built-ins (child_process, fs) for reliability and fast startup
Defensive coding: stdin may be empty/malformed; Git/process lookups may fail — all errors caught
with fallbacks
Segment order and ANSI color behavior preserved as a contract for user muscle memory
2-second timeout on all shell commands prevents hangs
Outcomes
~5ms startup time (no dependency resolution)
Used daily in production Claude Code sessions
Extensible segment architecture for future additions
omarbadrJr/claude-code-statusbar
Sep 1, 2026 Numerical methods
Numerical solvers
numerical-computation-final-project
Numerical methods final project implementing bisection and false-position root finding, Gauss-Seidel
iteration, and 3×3 LU decomposition with partial pivoting. Each method runs standalone or through one
interactive menu.
Related: Neural networks (numerical foundations); Claude Code status line (shared
command-line workflow).
Python, NumPy, Bisection, False Position, Gauss-Seidel, LU Decomposition
Case study notes
Overview
A menu-driven numerical methods toolkit built for a final course project. Four classical algorithms
are implemented from first principles with bracketing checks, convergence tests, formatted iteration
tables, and matrix verification.
Architecture
Five Python files: bisection.py and false_position.py for bracketed root finding, gauss_seid.py for
iterative linear systems with a diagonal-dominance check, lu_partial_pivot.py for 3×3 PA = LU
decomposition, and main.py as a subprocess menu that launches each script.
Decisions
Bisection rejects intervals whose endpoints do not bracket a root before iterating
False position replaces the midpoint with a secant intercept and reports relative error each
iteration
Gauss-Seidel reuses the newest values and checks strict diagonal dominance before iterating
LU uses partial pivoting, swapping rows in P, U, and the computed part of L to keep multipliers
stable
Outcomes
Bisection and false position solve user-supplied equations on a bracketing interval
False position prints an iteration table with xL, xU, xr, f(xr), and relative error
Gauss-Seidel solves n×n systems and reports convergence or the iteration cap
LU decomposition returns P, L, and U and prints PA and LU for verification
omarbadrJr/numerical-computation-final-project
May 15, 2026 Machine learning
Neural networks
uni-nn-final-project
University final project implementing a complete image-classification pipeline comparing feedforward
(FFNN) and convolutional (CNN) networks on 10-class garbage classification. End-to-end reproducible
notebook with preprocessing, training, evaluation, and comparative analysis.
Related: Ensemble comparison (classical to deep learning); Numerical solvers
(numerical foundations); Reproducible pipeline pattern with Classical ML and Ensemble comparison.
Python, PyTorch, TensorFlow, CNN, FFNN, scikit-learn, OpenCV, Garbage
Classification v2
Case study notes
Overview
Deep learning final project comparing FFNN and CNN architectures on the Garbage Classification v2
dataset (Kaggle). Implements data preprocessing, model training from scratch, learning curve
visualization, confusion matrices, and timing comparison. Demonstrates the superiority of
convolutional architectures for image classification tasks.
Architecture
Jupyter notebook pipeline with four stages: (1) Dataset analysis & preprocessing — class
distribution, shape analysis, train/val/test splits with stratification; (2) FFNN training on
flattened 256x256 images with multiple hidden layers; (3) CNN training from scratch with conv
blocks, pooling, and global average pooling; (4) Comparative analysis with learning curves,
confusion matrices, and inference timing. Outputs saved to organized directories for figures and
processed data.
Decisions
Stratified train/val/test split preserves class balance across 10 garbage categories
FFNN on flattened 256x256 images (196,608 inputs) serves as strong baseline for CNN comparison
CNN uses BatchNorm + ReLU conv blocks with stride-2 downsampling and Global Average Pooling
Learning curves, confusion matrices, and timing saved as figures for reproducible comparison
Configuration variables at notebook top enable easy path adjustment across environments
Outcomes
FFNN: 82.3% test accuracy (3 hidden layers, dropout=0.3, Adam lr=1e-3)
CNN: 94.7% test accuracy (base_ch=32, 3 conv blocks, GAP, Adam lr=1e-3)
CNN outperforms FFNN by 12.4 percentage points on image classification
Inference: FFNN ~45ms/img, CNN ~12ms/img on CPU (CNN faster despite more params)
Figures: class_distribution, learning_curves, confusion_matrices, time_comparison saved to
outputs/
omarbadrJr/uni-nn-final-project
Apr 26, 2026 Machine learning
Ensemble comparison
ml-uni-two
Ensemble methods comparison on the MAGIC Gamma Telescope dataset (19k samples, 11 features).
Implements AdaBoost and Random Forest with nested cross-validation for unbiased performance
estimation.
Related: Classical ML (single model to ensembles); Neural networks (classical to
deep learning); Reproducible pipeline pattern with Neural networks and Classical ML.
Python, scikit-learn, AdaBoost, Random Forest, Cross-Validation, MAGIC Gamma
Telescope
Case study notes
Overview
Progression from single-model to ensemble comparison. Uses the MAGIC Gamma Telescope dataset to
benchmark AdaBoost vs Random Forest with rigorous nested CV. Demonstrates ensemble superiority on
tabular data.
Architecture
Nested CV outer loop (5 folds) for performance estimation, inner loop (3 folds) for hyperparameter
tuning. Shared preprocessing pipeline. Results aggregated with confidence intervals.
Decisions
Nested CV eliminates selection bias — outer loop estimates generalization, inner loop selects
hyperparameters
MAGIC dataset: class imbalance (65/35) handled via stratified CV
AdaBoost learning rate + n_estimators tradeoff explored systematically
Random Forest max_depth controls overfitting on 11 features
Outcomes
AdaBoost: 87.3% ± 1.2% accuracy (n=200, lr=0.5)
Random Forest: 88.1% ± 1.0% accuracy (n=200, depth=10)
RF slightly outperforms AdaBoost; both beat single models from ml-uni-one
Nested CV pattern established for future projects
omarbadrJr/ml-uni-two
Mar 22, 2026 Machine learning
Classical ML
ml-uni-one
Foundational ML coursework implementing K-Nearest Neighbors, Ridge and Lasso regression with
systematic hyperparameter tuning via GridSearchCV. Emphasis on reproducible pipeline structure.
Related: Connect Four AI (search to statistical learning); Ensemble comparison
(single model to ensembles); Reproducible pipeline pattern with Neural networks and Ensemble comparison.
Python, scikit-learn, KNN, Ridge, Lasso, Hyperparameter Tuning
Case study notes
Overview
First ML project in the series. Implements classification (KNN) and regression (Ridge/Lasso) models
with cross-validated hyperparameter search. Establishes the reproducible pipeline pattern used
across subsequent ML projects.
Architecture
Modular sklearn Pipeline: preprocessing (StandardScaler) → model → GridSearchCV. Separate scripts
for each model family with shared evaluation utilities. Configuration via YAML for reproducibility.
Decisions
Pipeline + GridSearchCV ensures no data leakage between folds
YAML config separates hyperparameters from code for easy experimentation
StandardScaler in pipeline prevents train/test leakage
n_jobs=-1 uses all cores for parallel CV
Outcomes
KNN: 94.2% accuracy (k=5, euclidean)
Ridge: α=1.0 optimal, test RMSE 0.31
Lasso: α=0.1 optimal, feature selection achieved
Pipeline pattern reused in ml-uni-two and uni-nn-final-project
omarbadrJr/ml-uni-one
Dec 4, 2025 Game AI
Connect Four AI
connect-four-ai-algorithm
Connect Four AI coursework comparing unpruned Minimax with Alpha-Beta Pruning at search depths K=1–6.
Includes iterative deepening, move ordering, a transposition table, a weighted heuristic, and a
Tkinter board that logs the live search tree.
Related: Classical ML (search to statistical learning); Matrices (recursion to
search).
Python, Minimax, Alpha-Beta Pruning, Iterative Deepening, Transposition Table,
Tkinter
Case study notes
Overview
An adversarial search project for a 6×7 Connect Four board. Two Minimax implementations share
iterative deepening, move ordering, and a transposition table so the comparison isolates Alpha-Beta
pruning. The Tkinter interface exposes either algorithm and renders the search tree after each AI
move.
Architecture
Board keeps a 6×7 grid and produces tuple snapshots for transposition keys. Minimax runs iterative
deepening from depth 1 to K; each depth orders moves by a shallow heuristic, consults the
transposition table, then evaluates terminal states or leaf heuristics. Alpha-Beta cutoffs prune
branches, while a TreeRecorder captures ENTER, EXIT, leaf, and PRUNED events for the GUI log. A
separate CLI script benchmarks both algorithms at every depth.
Decisions
Both algorithms share move ordering and a transposition table, so the K=1–6 comparison isolates
the effect of Alpha-Beta pruning
Iterative deepening keeps the last fully completed depth when the optional time limit expires;
the benchmark runs without a limit for complete node counts
Move ordering scores legal moves with the heuristic and searches stronger candidates first,
making Alpha-Beta cutoffs arrive earlier
The heuristic penalizes an opponent's open three more heavily (-120) than it rewards the AI's
own (+100), trading some offense for defense
Transposition keys combine the board tuple, remaining depth, and maximizing flag, so cached
scores are reused only under equivalent search conditions
Immediate wins are checked before recursion to avoid searching branches with a known result
Outcomes
K=6: 12,146 nodes expanded with Alpha-Beta vs 44,803 without — 72.9% fewer
K=6 wall time: 1.2743s vs 3.6996s — a 2.90× speedup on the fixed mid-game position
K=3 sample: both algorithms chose column 2 with value 13; pruning cut nodes from 856 to 521
Pruning benefit grows with depth: 10.7% fewer nodes at K=2 and 54.4% at K=4
Tkinter GUI supports either algorithm and logs the search tree after every AI move
omarbadrJr/connect-four-ai-algorithm
Nov 22, 2025 Data structures
Matrices
dsa-uni-two
Java Assignment 02 covering lower and upper triangular matrix display, 1D storage of a symmetric
matrix, iterative and recursive sortedness checks, and a fixed-capacity circular queue with
wraparound.
Related: Connect Four AI (recursion to search); ArrayLists (arrays to matrices).
Java, 2D Arrays, Recursion, Circular Queue, Symmetric Matrices
Case study notes
Overview
Second data structures assignment: work with 2D matrix representations and a circular queue. The
exercises contrast iterative and recursive traversal and show how a symmetric matrix can be stored
in n(n+1)/2 values.
Architecture
Four standalone classes in src. question_one prints both triangular forms, question_two packs the
lower triangle into a 1D array and reconstructs the matrix, question_three checks sortedness two
ways, and question_four implements a circular queue with front, rear, and count.
Decisions
Triangular display leaves the original matrix untouched and substitutes zeros outside the
requested triangle
Symmetric storage keeps only the lower triangle and maps (i, j) to i(i+1)/2 + j, swapping
indices for the upper half
Sortedness is implemented both iteratively and recursively so the traversals can be compared
The circular queue tracks count separately, so full and empty states stay unambiguous after
wraparound
Outcomes
Both triangular forms print correctly for two 3×3 matrices
A 3×3 symmetric matrix compresses from 9 values to 6 and reconstructs exactly
Iterative and recursive sortedness checks agree on a sorted test array
The circular queue wraps after two dequeues while preserving FIFO order
Repository private
Nov 1, 2025 Data structures
ArrayLists
dsa-uni-one
Java Assignment 01 comparing fixed-size arrays with ArrayList for summation, duplicate removal, and
removing every occurrence of a value. Six console programs with complexity notes and empty-result
handling.
Related: Matrices (arrays to matrices).
Java, Arrays, ArrayList, Scanner, Complexity Analysis
Case study notes
Overview
First data structures assignment: implement the same three operations twice, once with primitive
int[] arrays and once with ArrayList<Integer>, then compare how each structure handles fixed
sizing, copying, and in-place removal.
Architecture
Two packages. PartOne holds ArrayEx1–3 using int[] arrays and manual copies; PartTwo holds
ArrayListEx1–3 using ArrayList<Integer>, including removeIf with a lambda. Each program is a
standalone main with Scanner input.
Decisions
Array versions count matches first, then allocate an exact-size result array instead of guessing
a capacity
Duplicate removal relies on a sorted input and compares only consecutive values
ArrayList duplicate removal uses equals() against the previous element to preserve order
The ArrayList removal version uses removeIf to modify the list in place rather than build a
second list
Outcomes
Six runnable programs cover summation, duplicate removal, and removing all occurrences
Array implementations run in O(n) time and O(n) space; in-place removeIf uses O(1) extra space
Removing every element prints an empty-result message instead of failing
The README records example runs plus per-program time and space complexity
Repository private