A showcase of my recent work and creative solutions
A comprehensive command-line shell implementation in C that handles process management, system calls, and I/O redirection. Features include background process execution, signal handling, and advanced shell scripting capabilities.
An efficient maze-solving algorithm implementation using breadth-first search to find the shortest path through complex mazes. Demonstrates graph traversal algorithms and data structure optimization.
A custom memory allocator implementation with performance optimization and multithreading support using pthreads. Features include thread-safe memory allocation, fragmentation reduction, and performance benchmarking.
Low-level assembly programming project involving x86-64 architecture and reverse engineering techniques. Combines assembly language with C integration for PuzzleBin, demonstrating system-level programming skills.
A fully responsive, interactive resume website built from scratch using HTML, CSS, and JavaScript. Features modern design principles, smooth animations, and dynamic content presentation to showcase professional experience and skills.
Advanced bit manipulation techniques combined with efficient hashset implementation and comprehensive debugging using GDB. Explores low-level programming concepts and data structure optimization.
Introduces functional programming in OCaml through implementing a collection of small functions involving arithmetic, recursion, list processing, and higher-order functions. Emphasizes recursive problem solving, immutability, type correctness, and use of higher-order abstractions such as map and fold under strict implementation constraints.
Implements a functional database system in OCaml using user-defined types and higher-order functions, supporting insertion, deletion, querying with logical conditions, sorting, updating, and bulk deletion. Additionally defines higher-order operations over binary trees, including fold-based implementations of mapping, traversal, mirroring, composition, depth calculation, trimming, and reconstruction from traversal orders.
Implements a regular expression engine by constructing and simulating finite automata. Includes NFA simulation, epsilon-closure and transition computation, subset construction to convert NFAs to DFAs, and translation of regular expressions into equivalent NFAs. Emphasizes formal language theory, functional programming techniques, and correctness of automaton-based execution.
Implements a dynamically typed OCaml-like language called MicroCaml by building a full lexer, recursive-descent parser, and interpreter. Supports features such as let and let rec bindings, anonymous functions, closures, records, conditionals, and arithmetic and logical expressions. Emphasizes language design, grammar-based parsing, lexical scoping, and environment-based evaluation.
Implements a static type checker for a subset of the C language (SmallC) and a constraint-based type inferencer for MicroCaml. Verifies type correctness across expressions and control flow, detects declaration and type errors, and performs unification-based inference to derive function and polymorphic types without explicit annotations. Emphasizes formal type systems and static program analysis.
Introduces systems programming in Rust through implementing utility functions that emphasize ownership, borrowing, iterators, pattern matching, and safe mutation. Expands into a comprehensive memory management project implementing three garbage collection strategies—reference counting, mark-and-sweep, and stop-and-copy—over simulated stack and heap structures. Emphasizes memory safety, graph reachability, pointer management, and runtime behavior under Rust’s safety guarantees.
Implemented an extensible stack supporting dynamic expansion and contraction based on amortized analysis principles. The stack automatically resizes during push and pop operations using configurable growth parameters, ensuring efficient memory utilization while maintaining constant amortized time complexity for stack operations.
Developed a binary search tree used as an index for a database of records. Implemented insertion, deletion, single-key queries, and range queries while maintaining parent, predecessor, and successor pointers to support efficient traversals and updates.
Implemented a modified B-tree supporting insertion, deletion, and search operations with custom balancing rules. Developed node splitting, merging, and sibling rotations while maintaining balanced multiway search tree properties for efficient storage and retrieval.
Implemented a generalized Scapegoat Tree supporting configurable balancing factors (α), insertion, deletion, and subtree rebuilding. Maintained token-based accounting for incremental and deferred rebuilding while preserving logarithmic search performance.
Implemented the Disjoint Set (Union-Find) data structure using weighted union and path compression. Applied the structure to Kruskal's Minimum Spanning Tree algorithm for graph processing and cycle detection.
This project develops and evaluates machine learning models to predict an individual's risk of stroke using demographic, lifestyle, and medical information. The objective is to identify key factors associated with stroke risk while comparing the performance of multiple classification algorithms.
How I approach systems programming projects
Understanding system requirements, analyzing performance constraints, and designing efficient algorithms and data structures.
Writing clean, optimized code with proper memory management, error handling, and adherence to best practices.
Comprehensive testing using GDB, valgrind, and custom test suites to ensure reliability and performance.
Performance profiling, code optimization, and thorough documentation for maintainability.