Coding Projects
I am a computer science major, so coding is one of the main ways I practice problem solving. My projects range from Java programs to low level assembly work to web design. Some of them were clean. Some of them fought back. All of them helped me learn how to break a problem down, follow logic carefully, and fix mistakes without pretending I was calm the whole time.
Java Encryption and Decryption Program
I built a Java program around encryption and decryption using a SimpleEncryptor class and a main class called ConvertComms. The program used a menu system so the user could choose between encryption and decryption options, including basic encryption, Caesar cipher encryption, Caesar cipher decryption, and AES-related concepts.
What I built: A menu-driven Java program that let users work through different encryption and decryption options while keeping the logic organized across multiple classes.
What I learned: This project helped me understand how data can be transformed, protected, and recovered through structured algorithms. I had to think carefully about user input, control flow, methods, string manipulation, and how to organize logic across multiple classes.
Engineering connection: Encryption depends on repeatable systems, rules, and predictable transformations. It also required debugging and careful testing, because one small logic error could make the output unreadable.
Skills: Java, object oriented programming, methods, classes, control flow, string manipulation, encryption concepts, debugging, user input handling
Cylinder Area File Processing Program
I built a Java program that calculated the surface area of cylinders using measurements from an input text file. The program read values from a file, processed the data, used custom area functions, and wrote the results to an output file using the provided CylinderArea and CylinderMainClass files.
What I built: A file-based Java program that took raw measurements, ran calculations, and produced organized output.
What I learned: This project focused on taking raw input, processing it through formulas, and producing clear output. It taught me how to work with file input and output, functions, and separating program responsibilities into different classes.
Engineering connection: This mirrors the process of taking measurements, applying a model, and producing useful results. The program had to be accurate, organized, and easy to trace.
Skills: Java, file input, file output, functions, classes, arithmetic formulas, debugging, data processing
MIPS Assembly Programming
I worked on several MIPS assembly exercises for a computer organization course. These included writing procedures, handling function calls, using registers, managing memory addresses, stack operations, and translating C-style logic into assembly. One assignment involved writing Sum and Dif procedures using $a0, $a1, and $v0. Another used shifts to multiply and divide values stored in memory.
What I built: Low-level programs and procedure-based assembly exercises that worked directly with registers, memory, and stack behavior.
What I learned: This work helped me understand what code looks like closer to the hardware level. I had to manage registers manually, think about memory, preserve values, and understand how procedure calls actually work.
Engineering connection: Assembly programming forces you to think about constraints. There is no hiding behind high level syntax. You have to understand what the machine is doing step by step, which made me think more carefully about efficiency, structure, and how small instructions build larger behavior.
Skills: MIPS assembly, registers, memory addressing, procedure calls, stack use, arithmetic instructions, shifts, low level debugging, computer organization
Cache and Computer Architecture Analysis
I completed computer organization work involving direct mapped caches, binary addresses, tags, indexes, hit and miss behavior, block size, SRAM requirements, and performance tradeoffs. I analyzed examples using word addresses and calculated how memory addresses map into cache locations.
What I built: This was more analysis than coding, but it was still technical problem solving built around system behavior and performance.
What I learned: This work helped me understand how software performance depends on hardware. I analyzed cache behavior and learned why memory layout, block size, and access patterns affect speed.
Engineering connection: This is about system design and tradeoffs. A larger cache is not automatically better. Capacity, metadata overhead, speed, and access patterns all affect performance.
Skills: Computer architecture, cache mapping, binary addresses, tags, indexes, performance analysis, memory systems, technical reasoning
Parallel Binary Search Speedup Analysis
I analyzed how binary search could be parallelized across multiple cores. I compared standard binary search to a version that checks multiple points in parallel, and reasoned about expected speedup using ideas like log2(Y + 1), coordination overhead, and Amdahl’s Law.
What I built: A performance analysis of an algorithm under parallel execution, focused on how theory and hardware limits interact.
What I learned: This project helped me think about algorithm performance, not just whether code works. I had to reason about runtime, parallelism, hardware limits, and the difference between theoretical speedup and real performance.
Engineering connection: This is optimization under constraints. More hardware does not always mean perfect speedup. The design has to account for overhead, coordination, and bottlenecks.
Skills: Algorithms, binary search, parallel computing, runtime analysis, speedup, Amdahl’s Law, performance modeling
Personal Portfolio Website
I built this personal portfolio website for a web development class using WordPress, Divi, and custom CSS. The site includes an about me section, a photo, project pages, and a background image I edited in GIMP. I also built separate pages for plumbing projects, aquascaping projects, and coding projects.
What I built: A real portfolio site that had to organize content clearly, look decent, work across pages, and reflect the kind of work I actually do.
What I learned: This project gave me experience designing and organizing a real website. I had to think about content structure, visual hierarchy, accessibility, responsive design, and how to present technical work in a way that makes sense to other people.
Engineering connection: Web design is a system of constraints. The site has to look decent, load correctly, be readable, work on different screens, and communicate information clearly. It also required iteration because nothing looks right the first time, which is rude but true.
Skills: WordPress, Divi, HTML, CSS, responsive design, accessibility, SEO basics, GIMP, content organization, visual design
What this work says about me
These projects show how I approach technical work. I like systems, structure, and problem solving. Coding gives me a way to practice those skills in a digital space, the same way my plumbing and aquascaping projects let me practice them in physical systems.