A robust, Django-based web application for managing patient records,
deployed on Render with PostgreSQL. Features interactive Chart.js
visualizations, real-time search, staff authentication, and data
export capabilities—built to showcase full-stack development skills
with a focus on usability and scalability. The system features patient
management with staff-only access to add, edit, delete, and view detailed
records. Interactive charts (bar, pie, line, heatmap) visualize patient
data, while a real-time sidebar tracks recent activity. A search function
allows filtering by key attributes, and staff can export data as CSV. Edit
history logs the last five changes per patient, and dashboard widgets
provide quick stats. The responsive Bootstrap UI includes dark/light
mode, and mock data with 60 Faker-generated patients supports testing.
GitHub Repo
A Python tool for analyzing genomic data, optimized for speed with parallel processing
(reducing runtime from 48.78s to 14.86s). Processes large FASTA files to identify cancer-related
DNA patterns, cross-referencing with the COSMIC Cancer Gene Census. Built for scalability
in bioinformatics research. Identified
6.4 million bases across cancer-related genes, pinpointing
5-mers like CTTTC (9,996 occurrences) in key cancer genes
such as FH (renal cancer), PRDM2 (tumor suppression), and
TAL1 (leukemia). By filtering high-frequency repeats, this
tool delivers specific, scalable, and disease-focused genomic
analysis—perfect for bioinformatics research.
analysis.
GitHub Repo
Image of a generated heatmap. See github for more graphs and details
The maze generation script uses a depth-first search (DFS) algorithm to carve paths into a grid initially filled with walls, ensuring paths are precisely one cell wide. Starting at a designated cell (1, 1), the algorithm explores random directions, carving two-cell-wide paths and marking the intervening walls as part of the path while maintaining surrounding walls. Dead ends are resolved through backtracking using a stack until all reachable cells are visited. An entrance at (1, 0) and an exit at (height-2, width-1) are manually carved after the maze is generated, creating a solvable maze with clear entry and exit points. The maze is then saved as a Portable Pixmap (PPM) file, where walls are represented in black (0 0 0) and paths in white (255 255 255), allowing for easy visualization in image viewers. The script ensures odd dimensions for proper maze structure, and its simplicity and flexibility make it an excellent tool for experimenting with procedural generation or learning algorithms.
Image of a generated maze and shortest path using a ppm file
The Pokémon Database project is designed to manage and analyze Pokémon data using PostgreSQL. The dataset was loaded from a CSV file obtained from Kaggle, and I used pandas to read the file and insert it into the database. The schema includes tables like example_table for storing Pokémon stats and types for categorizing Pokémon by type. This setup allows for various queries, such as calculating average stats for each type, retrieving Pokémon by their type or legendary status, and using a custom SQL function like avg_stats_by_type to get average stats for a specific type of Pokémon.
Image of a pgsql query to find avg stats by type
One of the things I experimented with was normalizing the data into separate tables for Pokémon, types, and their relationships. This made the database more flexible and efficient for querying. I also worked on optimizing the data insertion process by selecting specific columns (like pokemonname, attack, defense, and speed) and using pandas and SQLAlchemy to insert the data into PostgreSQL in chunks, which helped improve performance when handling large datasets. This approach made it easier to work with the data and allowed for faster queries and analysis.
RSA cryptography is a fundamental algorithm for secure data communication, relying on large prime numbers, modular arithmetic, and number theory. This implementation, written in C with the GNU MP (GMP) library for handling large integers, encompasses key generation, encryption, decryption, and digital signatures. The key generation process involves creating two large primes (p and q), calculating their product (n) as the modulus, and determining 𝜙(𝑛)ϕ(n) for selecting a public exponent e that is coprime to 𝜙 (𝑛)ϕ(n). Using the modular inverse, the private key d is derived. File-based functions securely store and retrieve keys, while modular exponentiation powers encryption (𝑐=𝑚𝑒mod 𝑛c=m e modn) and decryption (𝑚=𝑐𝑑mod 𝑛m=c d modn) processes. Block-based encryption and decryption ensure efficient handling of large messages, with dynamic sizing based on the modulus. Digital signatures enhance security by verifying authenticity. A message signed with a private key is validated by checking its integrity against the public key.
Image of file encrypt function
Key mathematical operations, such as GCD calculation for ensuring e is valid and modular inverse for computing d, underpin the algorithm's functionality. This implementation not only demonstrates the mechanics of RSA but also serves as a practical exploration of cryptographic principles, offering a robust and modular approach to securing data.
This code represents a parallelized password-cracking system that uses multiple servers to efficiently guess passwords encrypted with cryptographic hashes. The system utilizes both TCP and UDP protocols for communication between servers, with a focus on splitting the password cracking task across different nodes. The main function, depending on the host's identity (either "noggin," "thor," "nogbad," or "olaf"), orchestrates the distribution of password-cracking tasks. Each server attempts to crack different parts of the password space using a combination of multi-threading (via std::thread) and brute force. The password hash comparison is done by generating hash values for all possible combinations from a predefined character set and comparing them with the target hash. Upon success, the cracked passwords are sent back to the main server, where they are compiled into a final message. The system uses multicast UDP for receiving encrypted password hashes, which are distributed across the servers for cracking. The crackerjack function manages this process by spawning threads to break down the task into smaller chunks, leveraging the computational power of each server. Once each server has attempted its portion of the task, the results are communicated back to the main server via UDP. The passwords that were successfully cracked on the secondary servers are collected and integrated into the main result set. The use of parallel processing through threading and distributed computing across multiple machines accelerates the password-cracking process, making the system scalable and efficient.
Image of central cracker functions