Harris Mohamed

Overview

I was selected to deliver a plenary presentation on my research into expanding pattern-of-life capabilities for passive RF datasets. The work introduces a multivariate analytical framework that enables more nuanced anomaly detection compared to traditional univariate methods, applied across time-series RF metrics. This is a sequel to the work I presented at AMOS in 2023. Paper | Presentation

Overview

I was selected to deliver a plenary presentation on my research into detecting electromagnetic interference in passive RF data. The work develops methods for identifying EMI signatures within passive radio frequency datasets, improving signal integrity and operational awareness in contested electromagnetic environments. Methods explored include 1-shot image segmentation models, K-means clustering, and classical statistical methods. Paper

Overview

I gave a presentation on Monitoring Satellite Pattern-of-Life Changes with Passive Radio Frequency Data. This is very similar to my presentation at AMOS 2023. My work can be found at the following link. Presentation

Overview

I gave a presentation on Monitoring Satellite Pattern-of-Life Changes with Passive Radio Frequency Data. Here, I explored using statistical, time series, and machine learning approaches for univariate anomaly detection on time series RF datasets. I presented on some anomalies detected that have relevance to the Space Domain Awareness (SDA) mission. My paper can be found at the following link. Paper | Presentation

Overview

Sentinel Prime was a continuation of Project Sentinel. Sentinel Prime’s goal was to detect and classify 3D objects in indoor environments in real time. Originally, the idea was to pair Sentinel with a camera and use the existing LIDAR sensor, then employ a signal fusion network to combine the data and outperform existing 2D and 3D pipelines. Then, the computation would be performed on an FPGA or embedded device to attain real-time computation. However, I set my timeline a little too aggressively. At the start, my approach was to use an NVIDIA Jetson Nano to run existing KITTI models (KITTI is a challenging 3D dataset, a useful benchmark for 3D object detection and classification). The Jetson Nano actually gave me a lot of grief. The primary issue was the ARM-based architecture, which required me to build several libraries from scratch, which took an extremely long time. In the end, I was only able to get a few models running, and had very little time to actually pair the camera and LIDAR sensor. However, I got to explore the state of the art in 3D classification, including testing of Google’s Objectron model as well as some of the top-performing KITTI models. I also learned a lot about how to allocate time and perform literature reviews. Even though functionally Sentinel Prime was a failure, I learned a lot and will carry this forward in my career.

I also got the chance to test out some virtual simulators such as Microsoft AirSim, which I definitely aim to return to for another project.

Screenshot captured in the middle of an AirSim simulation

Advisor

Professor Deming Chen

Project Overview

Sentinel is a real-time LIDAR point cloud classification system developed as part of my undergraduate research. The system leverages FPGA acceleration to achieve real-time performance for autonomous vehicle applications.

Key Contributions

• Developed custom FPGA architecture for point cloud processing
• Implemented machine learning inference in hardware
• Achieved 10x speedup compared to software implementations

Results

The system was successfully demonstrated on a test vehicle and showed promising results for real-time object detection and classification in urban environments.

Overview

Atlas is a Discord-based AI council system where multiple LLM officers collaborate to strategize, brainstorm, and evaluate ideas. Right now, Atlas can spawn officers with multiple personalities to answer questions and conduct basic research on tasks. I want to grow this out to have the officers able to implement simple POCs using headless Claude Codes.

Project Overview

The War Room is an innovative multi-LLM (Large Language Model) interface designed to facilitate comprehensive AI-powered analysis by enabling simultaneous queries across multiple AI models. The project aims to provide users with diversified opinions and perspectives on any given question by creating a “council of LLMs with different personalities.”

Technologies Used

• Frontend: Next.js 15
• Language: TypeScript
• Styling: Tailwind CSS
• Database: Prisma with SQLite
• LLM Integration: OpenRouter API
• Deployment: Docker Compose

Key Features

• Parallel fan-out queries to multiple language models
• Capability tier system (Strategic, Operational, Tactical, Support)
• Persistent conversation sessions
• Side-by-side response comparison
• Mode indicators for capability tiers

Implementation Details

The War Room leverages modern web technologies to create a unique AI interaction platform. By using OpenRouter API, the application can query multiple AI models simultaneously, allowing for comparative analysis of different AI reasoning styles and strengths.

Challenges & Solutions

• Implementing parallel API calls while maintaining responsive user experience
• Designing a user interface that effectively displays multiple AI responses
• Managing session state and persistence across different model interactions

Results/Outcomes

The project demonstrates an experimental approach to AI consultation, providing users with a multi-perspective analysis tool that goes beyond single-model interactions.

Future Work

• Expand support for more AI models
• Implement more advanced comparison and analysis features
• Enhance session management and export capabilities

Demo/Documentation

Detailed project documentation and live demo available in the GitHub repository.

Overview

After my work for basic automated farming, I became really interested in how this could be applied to vertical farming. Check back here for updates on how I attempt to implement vertical farming at a global scale to revolutionize how food distribution and production works.

Overview

I recently downloaded and began visualizing some of my Facebook Messenger messaging data, which led me to consider what an AI would think of my messages. This project will use AI to analyze intent, emotion, mood, and predict future messages.

Originally, I intended to revisit this project. However, the advent of mature LLMs actually led me to abandon this project. I might return to it at some point, but as of 2026 this is abandoned.

Overview

The RISC-V pipelined CPU is the capstone assignment in ECE 411: Computer Organization and Design. This is an intensive course that teaches fundamentals in computer architecture and then those fundamentals are designed in System Verilog. Working in a group with 2 others, we designed a 5-stage 32-bit classic RISC-V processor that could perform hazard detection and data forwarding.

My Contributions

I played a significant role in implementing the base CPU and had the chance to augment the CPU with the RISC-V M extension, which supports multiplication and division operation. I decided to use the well-known Wallace Tree to achieve a faster multiplication than an algorithm like add-shift. For the divider, I used a shift-subtract algorithm.

Future Work

Although I enjoyed this course, I feel that I could accomplish a lot more with more time. I am planning to revisit this CPU design and augment additional features, such as a tournament branch predictor, multiple-way L1 caches, and . My ultimate goal is to program an FPGA with this CPU and run actual code on it. I might even pursue Tomasulo’s algorithm, as that algorithm makes much more sense to me than a pipeline. Due to academic integrity violations, I can’t upload the CPU from my class but I will update my GitHub if I make something else not in a class.

Overview

This was the final project for ECE 420, Signal Processing Lab. The final project is to take any signal processing application described in a paper and implement it on an Android app. I worked with a partner to create Eigenmask: an application of Eigenfaces with the purpose of distinguishing not only who the person is, but whether or not they are wearing a mask.

Process

The Eigenface algorithm works by finding the eigenvectors from the covariance matrix of the probability distribution over the extremely high-dimensional vector space of face images. This provides dimensionality-reduction, and unknown faces can be classified by comparing them to the eigenvectors determined in training. Training was done on Python, and this was ported over to Android. The project was a success, able to distinguish a few friends and I, as well as whether we were masked or maskless.

Overview

I’ve always had an interest in using AI for text generation. One of my friends is a part of a website called Hybris Forum where they publish articles discussing technology, culture, and the dysfunction of technology with society. That same friend suggested I write an article as well, but writing it definitely not my strong suit. This was the perfect opportunity to experiment with text generation AIs. The current state of the art is GPT-3, a transformer network developed by OpenAI. Unfortunately, GPT-3 is not available to the public, because the text it generates is too realistic to that written by humans.

Rather than go through the effort of training my own network, I decided to use GPT-2. The creators have open sourced a smaller version of GPT-2, which implies that it is bad enough to be given open access to, which is something I found out firsthand. The way I generated the article was by writing a long essay, and then finetuning the 355M model of GPT-2. After this, I generated lots of output text with input prompts. It was pretty painful to sort through the outputs and get something usable, and after spending a few days I didn’t have enough text for an essay. Out of frustration, I turned to InferKit, a working demo of GPT-2. This was useful for the transitions in the essay.

Check my Git to find the final Colab notebook I used. Unless GPT-3 gets released, I won’t be pursuing this project any further. I would honestly call this a failure, but the final essay (also on my Git) is pretty coherent.

Overview

I have always had an interest in 3D design, modeling, and rendering (very much reflected by my research interests). I’ve been learning Blender ever since I built my new desktop. I am still a novice, but I have a few intro projects I have completed, and have many more planned. I upload all my renders on my VFX YouTube channel, Ethereal Studios.

More coming soon! I plan to experiment with physics simulations and video compositing.

Overview

This was the final project for ECE 391, an intensive design course where I worked with a group of 4 to write code to design a unix-like operation system. This operating system (dubbed LC-4 after our university’s toy ISA, LC-3) featured device drivers (for terminal, file system, interrupt controller, real-time clock), support for system calls, context-switching, virtualization, and a round-robin scheduler.

Details

The following are some details that I worked on to implement this OS.

• Device Drivers

  • Interrupt controller: I programmed the PIC-8925A interrupt controller to interface with our OS. After this was complete, we could have the keyboard and real-time clock register as interrupts.
  • Real-time clock: All programs need some way to track time. I studied the datasheet for the RTC chip in order for it to interface with our OS.

• System calls

  • Once the interrupts were enabled, I set up support for system calls to be made.

• Context-switching

  • In order to run user programs, there is a context-switch that needs to happen: from the kernel space to the user space. This context switch needed considerable assembly code and something or other

• Scheduling

  • This was one of my favorite parts of the OS. At the point, we had three terminals and coded them such that they ran all at once. The scheduler would context switch between all 3 terminals using a special clock chip that was connected to interrupt line 0

One of my group members uploaded a video of our final OS here.

Project Description

For the final project in ECE 408 (Applied Parallel Programming), I implemented a ray tracing renderer using NVIDIA CUDA to leverage GPU parallelization for significant performance improvements.

Implementation

Core Features

• Sphere and plane primitive support
• Phong reflection model
• Shadow ray casting
• Reflective surfaces
• Anti-aliasing through supersampling

CUDA Optimization Techniques

• Thread-per-pixel parallelization
• Shared memory for scene data
• Texture memory for acceleration structures
• Occupancy optimization
• Memory coalescing

Performance Results

Compared to a single-threaded CPU implementation:

• 10x speedup on simple scenes
• 50x speedup on complex scenes with reflections
• Achieved real-time rendering for simple scenes at 720p

Profiling Insights

• Memory bandwidth was the primary bottleneck
• Optimizing memory access patterns provided the largest gains
• Kernel launch overhead minimized through larger workloads per kernel

Technical Challenges

1. Ray-surface intersection - Implemented efficient bounding volume hierarchies
2. Divergent execution - Minimized warp divergence through scene organization
3. Memory management - Careful allocation and transfer between host and device

Course Context

ECE 408 - Applied Parallel Programming focused on heterogeneous parallel programming with emphasis on GPU architectures and CUDA programming. This project showcased the performance potential of GPU acceleration for computationally intensive graphics tasks.

Overview

innovateFPGA is a competition hosted by Terasic, where FPGAs are applied towards problems that involve AI at the edge. In this vein, my colleague and I submitted a proposal for Project Watchdog, an FPGA-based smart home security camera that performed all classification locally and only sent the output of the classification to a computer, thus reducing the amount of bandwidth needed to send video to an external server. In addition, this solution does not need an internet connection to perform a classification.

We placed as regional finalists in the competition, and our full write-up can be found here.

Overview

For my internet of things class, I designed and implemented an automated farming setup. I grew lettuce, tomatoes, and strawberries indoors. The water delivery was automated, and the plants were monitored with a real-time dashboard using several sensors (temperate, soil moisture, etc.). A camera was set up to capture a time lapse. A video summarizing my conclusion can be found at the link below:

Video

Overview

Every year, UIUC holds a competition called a Hackathon. The hackathon is a 36-hour competition where the competitors are asked to design (usually code) anything they can think of or find interesting. The goal is to create the most novel and working design in 36 hours. Since I was in an ECE fraternity (HKN), I wanted to create something with hardware to challenge myself, and also help me with job applications for internships.

Details

The idea is novel, but is a bit ambitious for a 36 hour competition. We set out to develop a non-invasive EEG wave capture device that could map thoughts. Using affordable hardware components and machine learning algorithms, we created a proof-of-concept system that could detect specific thought patterns.

The project involved:

• Hardware assembly and circuit design for EEG sensors
• Signal processing and noise filtering
• Machine learning model training for pattern recognition
• Real-time data visualization interface

Results

Winner of the HackIllinois 2019:

• Ocean Source Software (presented by Particle)
• The Very Hungry Caterpillar (presented by Caterpillar)
• Runners Up for the event overall

This project demonstrated the potential of accessible brain-computer interfaces and opened doors for future research in this area.

Overview

This was our final project for ECE 385, an introductory course about realizing digital designs on FPGAs. The project is named “Project LD”, which is short for “Projects Legends Never Die”, which is a nod to our professor, whose profile picture on our class website is the “Legends Never Die” meme.

Details

This project was originally meant to be augmented reality beer pong (without the beer). The goal was to track a bouncing ping pong ball using a camera in 3-dimensions in realtime and then superimpose the path of the bouncing ball on the video feed as well as superimpose the path that should have been taken to get the ball into the cup. We were able to get a successful 2D track of the ball’s position and scale, but did not have time to work on the 3D track. For this project, we used the DE2-115 expansion board with the Altera Cyclone IV E FPGA. We were provided with the 1.3 megapixel camera module, and spent a majority of the project interfacing the camera with the FPGA. By the end of 2 weeks, we were able to have a fully functioning 1.3 megapixel camera outputting its feed via VGA to a computer monitor. In addition, we were able to interface the NIOS II E microcontroller as a System-on-chip to toggle the camera settings. We made heavy use of exposure, red gain, blue gain, and green gain settings to achieve the best picture quality we could. The tracking was done very similar to how the visual effects software Adobe After Effects achieves its 2D motion track: In After Effects, you choose the point you want to track, and it generates a small box on the screen. Frame-by-frame, it then tracks the change in position and scale by looking at the change in high contrast points within the box. We made an FPGA-module to do the exact same thing, except in realtime. It worked rather well, but could not keep the track if the ball was dropped. The reason for this is we need to add a module that accomplishes frame interpolation. Since a falling ball falls very fast relative to the frame, comparing the frame before the drop to the frame after the drop will show a large vertical change between frames. Frame interpolation will guess where the ball would have been between the frames, and would allow for a much better track.

Progress Video

Watch the progress video

Overview

Illini Formula Electric (IFE) is a club at UIUC where we design and build a formula-style electric racecar from scratch. The club is entirely student-run. In the summer we compete at the FSAE competition in several events. I was a member of IFE for two years, detailed below.

2017-2018

We were limited to 300V (that limit has since be raised to 600V). The battery that our car runs off of is comprised of 336 LiFePO4 cells that are wired together in a series-parallel combination that yields 300V and 175A overall. The competition rules require us to monitor the temperature and voltage of each battery cell. The old method of doing this was using the Elithion Proprietary Battery Management System (BMS). This system only runs on very old team laptops, which are archaic, cumbersome, and limited to a hardwire connection. As a freshman, I designed a PCB that could read data off the CAN bus and then output it over bluetooth to a laptop.

I also developed a GUI that was capable of outputting the data in realtime. This was done in C# using the .NET framework.

2018-2019

After my first year on IFE, I got promoted to the leader of the Data Acquisition and Quantitative Analysis (DAQA) team, whose primary goal is to log data from all the sensors on the car, timestamp them, and then upload it to a server. It gathers data from 4 accelerometers, 30 strain gauges, a GPS, the position of the steering wheel, the coolant temperature, the brake pressure, the throttle and regen pedal potentiometer, CAN, hall effect sensors, and the voltage of the low voltage battery pack.

The system consisted of Raspberry Pi Zero boards with a custom PCB on top of each Pi. There would be one board near each tire and one in the center, by the driver’s seat, which would distribute the data evenly across each board. Each Pi would then send data to the central pi, which would then timestamp and upload the data. The data would then be parsed and analyzed using AWS. Due to time constraints and hardware issues, the final system did not work as intended. However, it was a valuable learning experience.

Overview

As part of the 2018 ECE PULSE competition, me and 3 other group members interfaced a Tobii eye tracker with a C# application to assist those with dyslexia. This would operate by using OCR to analyze when someone is trying to read text on a computer screen and based on how long someone is looking at text, analyze if they are having trouble reading it. Then, it can take the data and then graph it. Due to time constraints, we were only able to get the eye tracker data and figure out what parts of the screen were being looked at. We were 2nd place runners up in the competition.

Overview

S.T.E.V.E. (which stands for Self Teaching Elevated Vehicle Entity), is a drone designed from scratch that was designed to serve as an aid during natural disasters. S.T.E.V.E. was designed for Senior Tech, which was a high school capstone course where we could work on any STEM related project for a year. The concept was to create an autonomous drone capable of surveying locations where individuals stranded in dangerous situations could be without risking the life of an emergency responder. To accomplish this, we made a fully featured drone with a custom flight controller, camera to view the surroundings (to live stream what the environment looks like back to a VR headset at the base station), a speaker with an onboard AI (to communicate to a victim of a natural disaster), and sensors (to make sure it doesn’t fly into any obstacles as well as update location). Even though we were extremely ambitious and did not meet all of our goals, this project was ultimately a success. The project was met with high praise and was presented at a limited engineering expo at Navistar. This is also the project that made me realize I wanted to be a Computer Engineer, as this project was worked on during the time in which I applied to colleges. Working on this project made me realize my love for combining hardware and software to produce something greater than the sum of its parts.

Flight Controller

A crucial part of any drone is the flight controller. The flight controller is responsible for controlling the speed of each motor to Most drone projects will use an inexpensive off-the-shelf flight controller that takes care of all the flight algorithms. All you have to do is plug in the motors and battery to have a functional drone. However, we thought it would be better as a learning experience if we designed and programmed the flight controller from scratch. We used an Arduino MEGA as our primary microcontroller and an inexpensive MPU-6050 as our Inertial Measurement Unit (IMU). We then progreammed a PID controller to realize our flight controller. This took a bulk of our school year (and grew into a thousand line plus program) but was an incredibly rewarding experience. The microcontroller was programmed in C/C++ using the Arduino IDE.

Camera/Virtual Reality Headset

The goal here was to come up with a way to stream camera footage from the drone back to a virtual reality headset. This could be used to allow emergency responders to remotely survey a disaster area without the need to send in personnel. From an engineering standpoint, it is an interesting feature to try to implement. We used a Raspberry Pi 3 as the computer and Raspberry Pi Camera for the camera. There were two reasons we went with this combination: (1) Raspberry Pis (and their cameras) are cheap, easy-to-use and well documented, and (2) This allowed to split the hardware for the project into two categories: flight essential and not flight essential. One of the most important factors optimized in a flight controller is how long the main loop of the code takes. The faster (typically) the better. By separating the hardware into what was essential for flight and what wasn’t, we could could aggressively optimize the flight controller and still have other devices on the drone. If we tried to get the Arduino to compute and transfer the camera footage, the flight loop might get severely impacted and the drone would no longer fly smoothly.

Speaker/AI

This is also not flight essential hardware and was supported by the Raspberry Pi (this was made simple by the fact that there is an audio out jack on the Pi). The main goal here was to give STEVE a natural language artificial intelligence so that STEVE could talk to people and let them know help is on the way. The initial thought was to use simple if-else constructs and hard-code the speaker outputs (i.e. “Help is on the way”), but then we had the idea of using IBM AI APIs to get a natural language output from the Raspberry Pi. After struggling for a few weeks with the IBM documentation, we contacted them and they sent us a sample Android app that used their APIs. After this, it was easy to link this with the Raspberry Pi and output it through the speaker. We trained the AI and attempted to make the outputs as helpful as possible in the relevant situation.

Object Detection and Location Updates

One fundamental aspect of a drone is to not fly into nearby objects. Real drones use laser-detection to detect nearby objects, but those sensors are expensive and difficult to get working so we chose to use inexpensive ultrasonic sensors. Our end goal was to have 6 sensors in each axis, 3 in each direction (for instance, we would have 3 pointing directly upwards and 3 pointing directly downwards, thus covering the z-axis). We used a MUX shield, which adds 37 additional inputs to the Arduino and we ended up writing our own custom drivers to capture the ultrasonic values (it turns out provided library functions start to fail when you try to use an external shield). The driver code worked perfectly fine, but due to time constraints we were not able to interface it with the rest of the drone. We were able to add an off-the-shelf GPS module, which was capable of logging the drone’s coordinates. Combined with the ultrasonic sensors, we were able to show that we could capture coordinates in 3-dimensions.

Even though we were not able to meet all of the goals we set for the project, we consider STEVE an incredible success.

Overview

The first programming language I learned was Javascript. From there, I use Codeacademy to learn HTML and CSS, and I was cranking out simple, unaesthetic webpages like nobody’s business. During high school, a trend that took off (and is still extremely relevant today) is “shipping” people together. “Ship” is short for relationship, and it essentially means pairing people together as couples. This idea led directly to the Shipping Generator. We loaded everyone’s name from our classes, and everytime “Generate” was clicked, a boy’s name and a girl’s name would be chosen at random. Incredibly simple, but the project took off and soared in popularity. The generator got hundreds of page requests a week, a lot of which was actually during class time, since the website was not blocked by the firewall. People began asking for more features, the most prominent of which ended up being a leaderboard. Designing a leaderboard in high school with no concept of what databases were was actually a difficult task, but we ended up having the website complete a Google Form and then had a public readonly spreadsheet where we sorted the results. This led to people figuring this out and filling out the forms themselves, which led to us adding in obfuscation and security features. While rudimentary, still one of my favorite projects that I have worked on.

Role Overview

Artificial Intelligence Engineer at Kratos Defense & Security Solutions in Colorado Springs, CO, focusing on developing advanced machine learning pipelines for Space Domain Awareness (SDA) operations and deploying secure AI infrastructure for engineering teams.

Key Responsibilities

• Developing unsupervised clustering pipeline to identify satellite behavioral patterns in terabytes of passive radio frequency datasets; experimenting with autoencoder-based feature extraction and density-based clustering (DBSCAN, BIRCH) to enable automated anomaly detection and reduce manual pattern analysis for Space Domain Awareness operations
• Deploying secure LLM infrastructure for engineering teams by integrating OpenWebUI with AWS Bedrock and Claude Code, establishing data sovereignty controls and enabling AI-assisted development while maintaining compliance with network restrictions

Projects & Achievements

• Designed and implemented unsupervised clustering pipeline for satellite behavioral pattern analysis using terabytes of passive RF data
• Successfully deployed secure LLM infrastructure integrating OpenWebUI, AWS Bedrock, and Claude Code for engineering teams
• Established data sovereignty controls and compliance frameworks for AI-assisted development in restricted network environments
• Enabled automated anomaly detection capabilities to reduce manual pattern analysis workload in SDA operations

Technologies & Tools

• Machine Learning: Autoencoders, DBSCAN, BIRCH, unsupervised clustering algorithms
• AI Infrastructure: OpenWebUI, AWS Bedrock, Claude Code
• Data Processing: Large-scale RF dataset analysis (terabytes)
• Security & Compliance: Data sovereignty controls, network restriction compliance
• Domain: Space Domain Awareness (SDA), satellite behavioral analysis

Skills Developed

Advanced expertise in unsupervised machine learning and clustering techniques for large-scale RF data analysis. Gained deep experience in secure AI infrastructure deployment, including LLM integration with cloud services while maintaining strict security and compliance requirements. Developed proficiency in autoencoder-based feature extraction and density-based clustering algorithms for anomaly detection in satellite communications.

Impact/Results

Enabled automated anomaly detection for Space Domain Awareness operations, significantly reducing the need for manual pattern analysis of satellite behavioral data. Empowered engineering teams with secure AI-assisted development capabilities through compliant LLM infrastructure deployment, maintaining data sovereignty while enhancing productivity.

Team/Collaboration

Supporting multiple engineering teams across Kratos Defense & Security Solutions by providing AI infrastructure and tools. Collaborating with SDA operations teams to develop machine learning pipelines that enhance satellite monitoring and analysis capabilities.

Role Overview

Software Development Engineer II at Kratos Defense & Security Solutions, focusing on building scalable data infrastructure and developing analytics prototypes for Space Domain Awareness operations. Worked with the Kratos Global Sensor Network to support mission-critical assessments through data engineering and collaborative analysis.

Key Responsibilities

• Delivered unified data ingestion solution by developing Dagster-based pipeline and resolving critical failures across 20 edge nodes, enabling stable large-scale ingestion into a 65M+ row Data Lake optimized for high-performance querying
• Developed analytics prototypes for bandwidth utilization, maneuver detection, and RF interference identification, collaborating with cross-functional domestic and international teams to support mission-critical Space Domain Awareness assessments
• Regularly presented proof-of-concept analyses to senior stakeholders, translating findings into operational insights for the Kratos Global Sensor Network and driving alignment across engineering, operations, and customer teams

Projects & Achievements

• Built and deployed Dagster-based data ingestion pipeline handling 65M+ row Data Lake across 20 edge nodes
• Resolved critical failures in distributed edge infrastructure, achieving stable large-scale data ingestion
• Created analytics prototypes for bandwidth utilization monitoring and optimization
• Developed maneuver detection algorithms for satellite behavioral analysis
• Implemented RF interference identification system for signal quality monitoring
• Successfully presented multiple proof-of-concept analyses to senior leadership, driving operational decisions

Technologies & Tools

• Data Engineering: Dagster, Data Lake architecture, ETL pipelines
• Analytics & Prototyping: Bandwidth utilization analysis, maneuver detection, RF interference identification
• Infrastructure: 20-node edge computing network, high-performance query optimization
• Collaboration: Cross-functional team coordination (domestic and international)
• Domain: Space Domain Awareness (SDA), Kratos Global Sensor Network

Skills Developed

Advanced data engineering expertise in building and maintaining large-scale ingestion pipelines using Dagster for mission-critical Space Domain Awareness operations. Developed strong capabilities in distributed systems troubleshooting across edge computing infrastructure. Enhanced analytical prototyping skills for RF data analysis, including bandwidth utilization, satellite maneuver detection, and interference identification. Strengthened stakeholder communication by regularly presenting technical proof-of-concept work to senior leadership and translating complex findings into actionable operational insights.

Impact/Results

Enabled stable, large-scale data ingestion into a 65M+ row Data Lake by resolving critical failures across 20 edge nodes, supporting high-performance querying for Space Domain Awareness operations. Empowered mission-critical assessments through analytics prototypes that identified bandwidth utilization patterns, detected satellite maneuvers, and flagged RF interference. Drove organizational alignment by translating proof-of-concept analyses into operational insights for engineering, operations, and customer teams at the Kratos Global Sensor Network.

Team/Collaboration

Collaborated extensively with cross-functional domestic and international teams to develop and deliver analytics prototypes for Space Domain Awareness. Regularly interfaced with senior stakeholders to present technical findings and drive decision-making. Worked across engineering, operations, and customer teams to ensure alignment on data infrastructure and analytical capabilities for the Kratos Global Sensor Network.

Overview

I worked on a GPU simulator written in C++, profiling the simulator using Visual Studio and optimizing the simulator to perform more efficiently.

Role Overview

System Software Engineering Intern at Kratos Defense & Security Solutions during Summer 2020.

Responsibilities

• Software development for defense systems
• System integration and testing
• Collaboration with engineering teams

Technologies

• Software development tools
• System integration platforms
• Defense industry standards

Role Overview

System Design/Architecture Engineering Intern at Kratos Defense & Security Solutions during Summer 2019.

Responsibilities

• System architecture design
• Hardware/software integration
• Technical documentation
• Collaboration with engineering teams

Technologies

• System design tools
• Architecture frameworks
• Defense industry standards

Role Overview

Embedded Software Intern at Continental Automotive during Summer 2018.

Responsibilities

• Embedded software development for automotive systems
• Testing and validation of embedded systems
• Code debugging and optimization
• Collaboration with hardware teams

Technologies

• C/C++ programming
• Embedded systems platforms
• Automotive industry standards
• Real-time operating systems

Role Overview

Product Systems Intern at Weber Packaging Solutions during Summer 2017.

Responsibilities

• Product systems design and development
• Testing and quality assurance
• Technical documentation
• Cross-functional team collaboration

Technologies

• Product development tools
• Testing equipment
• Manufacturing systems
• Documentation platforms

Overview

Served as an Undergraduate Course Assistant for ECE 385: Digital Systems Lab, helping students with FPGA programming using SystemVerilog and providing guidance on digital design projects.

Responsibilities

• Assisted students with FPGA development on Altera DE2-115 boards
• Provided guidance on SystemVerilog syntax and digital design concepts
• Held weekly office hours for debugging and project consultations
• Graded lab assignments and provided constructive feedback
• Supported students through final project development

Skills Developed

• Technical communication and mentoring
• FPGA design patterns and best practices
• SystemVerilog and digital systems design
• Debugging and problem-solving strategies

Course Description

CS 411: Database Systems provides comprehensive coverage of modern database technologies, from traditional relational databases to NoSQL and graph databases. The course covers both theoretical foundations and practical implementations.

Topics Covered

• SQL fundamentals and advanced queries
• PostgreSQL relational database
• MongoDB document-oriented database
• Neo4j graph database
• Database design and normalization
• Query optimization
• Transaction management
• NoSQL vs. SQL tradeoffs

Skills Gained

• SQL query writing and optimization
• PostgreSQL database administration
• MongoDB document database design
• Neo4j graph database modeling
• Database schema design
• Multi-paradigm database selection
• Performance tuning and optimization

Course Description

CS 437: Internet of Things explores the fundamental concepts and technologies behind IoT systems. The course covers everything from low-level network protocols to cloud-based IoT platforms, with hands-on experience using AWS services.

Topics Covered

• IoT network stacks and architectures
• Common IoT protocols and standards
• AWS Glue for data integration
• AWS Greengrass for edge computing
• AWS Aurora for database management
• IoT device communication patterns
• Edge and cloud computing integration

Final Project

Automated farming system demonstrating end-to-end IoT implementation, from sensors to cloud-based data processing and control.

Skills Gained

• IoT system design and architecture
• AWS IoT service implementation
• Protocol selection and implementation
• Edge computing concepts
• Cloud-based data management
• End-to-end IoT solution development

Course Description

CS 441: Applied Machine Learning provides a comprehensive introduction to machine learning algorithms and their practical applications. The course covers both classical machine learning techniques and modern deep learning approaches.

Topics Covered

• Convolutional Neural Networks (CNNs)
• Support Vector Machines (SVM)
• Clustering algorithms
• Neural network architectures
• Supervised learning methods
• Unsupervised learning techniques
• Model evaluation and validation
• Feature engineering

Skills Gained

• Machine learning algorithm implementation
• CNN architecture design and training
• SVM classification
• Clustering analysis
• Model selection and evaluation
• Practical ML project development
• Python machine learning libraries

Course Description

CS 498: Cloud Computing Applications provides comprehensive training in modern cloud computing technologies and architectures. The course focuses on building scalable applications using industry-standard cloud platforms and big data processing frameworks.

Topics Covered

• Cloud infrastructure fundamentals
• AWS EC2 instances and configuration
• Hadoop distributed computing
• Apache Spark for big data processing
• ETL (Extract, Transform, Load) pipeline design
• Scalability and performance optimization
• Cloud service architectures

Skills Gained

• AWS cloud platform expertise
• Distributed computing with Hadoop
• Big data processing with Spark
• ETL pipeline development
• Cloud infrastructure design
• Scalable application development

Course Description

CS 598: Deep Learning for Healthcare covers advanced deep learning techniques applied to healthcare and medical data. The course provides comprehensive coverage of modern deep learning architectures and their applications in healthcare domains.

Topics Covered

• Convolutional Neural Networks (CNNs)
• Recurrent Neural Networks (RNNs)
• ResNet architectures
• Transformer models
• Graph Neural Networks (GNNs)
• Healthcare-specific applications

Final Project

Transfer learning used to classify what activity is being performed based on smartwatch metrics. The project demonstrated practical application of deep learning techniques to wearable sensor data for activity recognition.

Skills Gained

• Deep learning architecture design
• Healthcare data analysis
• Transfer learning techniques
• Model training and optimization
• Working with time-series sensor data

Course Description

ECE 310: Digital Signal Processing covers the theory of Digital Signal Processing. The course was heavy in mathematics, but the concepts from this class show up in several places: the lab, internships, and real-world applications. The associated lab section (ECE 311) used Python to visualize many of the concepts taught in the classroom.

Topics Covered

• Discrete-time linear shift-invariant systems
• Difference equations
• Convolution and impulse response
• Z-transform
• Transfer functions and block diagrams
• Discrete-time Fourier transform (DTFT)
• Sampling Theory
• A/D and D/A conversion

Lab Component (ECE 311)

The lab section provided hands-on experience with DSP concepts:

• Python implementation of DSP algorithms
• Visualization of frequency and time domain signals
• Practical applications of theoretical concepts
• Signal analysis and processing

Skills Gained

• Digital signal processing theory
• Z-transform analysis
• DTFT and frequency domain analysis
• Sampling and quantization
• Python signal processing
• Filter design fundamentals
• Time and frequency domain conversion
• Mathematical signal analysis

Course Description

ECE 385: Digital Systems Lab covers several topics that are important to the field of programming and using FPGAs. Similar to parallel programming, impressive speedups can be achieved using FPGAs. This was one of the favorite courses, providing hands-on experience with FPGA development and digital system design.

Topics Covered

• Combinational logic circuits - Basic digital logic design
• Storage elements - Registers, flip-flops, and memory
• Hazards and race conditions - Timing analysis and prevention
• Circuit characteristics - fanout, delays, propagation times
• Field Programmable Gate Arrays (FPGAs) - Architecture and programming
• Combinational networks - adders, multiplexers, etc. in SystemVerilog
• Sequential networks - counters, shift registers, etc. in SystemVerilog
• Synchronous state machines - FSM design and implementation
• Static timing analysis - clock domains, metastability, and synchronization
• Logic simulation and testbenches - Verification methodology
• Microprocessors and system on chip - Embedded processor integration

Key Projects

Implemented a match moving algorithm using:

• Camera interface and image capture
• FPGA-based image processing
• Real-time video processing pipeline
• Hardware-accelerated computer vision

Skills Gained

• FPGA programming and design
• SystemVerilog HDL
• Digital logic design
• State machine implementation
• Timing analysis and optimization
• Hardware debugging
• Testbench development
• Computer vision on FPGAs
• Real-time video processing

Course Description

ECE 391: Computer Systems Engineering is all about the synthesis between hardware and software, working together to make a Linux-like operating system. This starts from nothing more than a few boot files. The final operating system has a read-only filesystem, interrupt support, device support (Keyboard, Interrupt Controller, Real time clock), paging, and a round-robin scheduler for multitasking. The operating system was completed in a group of 4.

Topics Covered

• Interfacing C to assembly - macros, stack frame and calling convention
• Synchronization - primitives, memory semantics, mutual exclusion, semaphores, scheduling, and race conditions
• Interrupts - controlling generation and handling, chaining, cleanup code, interactions with device functionality
• Resource management - virtualization and protection, virtual memory and hardware support
• Exceptions and signals - exceptions due to instructions, memory accesses, and floating-point operations; signal semantics and delivery
• Device programming - basic abstractions, character and block devices
• File system abstractions - disk layout, access control lists and capabilities, log-structured and traditional filesystems as design problem
• I/O interface - file descriptors, buffering, control operations, memory mapping

Key Projects

Built a complete Linux-like operating system from scratch featuring:

• Read-only filesystem
• Interrupt handling system
• Device drivers (Keyboard, Interrupt Controller, Real-time clock)
• Virtual memory with paging
• Round-robin multitasking scheduler
• Process management
• System call interface

Skills Gained

• Operating system design and implementation
• Low-level C and assembly programming
• Hardware-software interaction
• Device driver development
• Memory management
• Process scheduling
• Interrupt handling
• Filesystem implementation
• Team-based systems programming

Course Description

ECE 408 focuses on heterogeneous parallel computing with emphasis on GPU architecture and CUDA programming. The course covers:

• GPU architecture and memory hierarchy
• CUDA programming model
• Performance optimization techniques
• Parallel algorithm design

Key Projects

• Matrix multiplication optimization
• Convolution implementation
• Ray tracing renderer (final project)

Skills Gained

• CUDA C/C++ programming
• Performance profiling and optimization
• Understanding of GPU memory hierarchies
• Parallel algorithm design and analysis

Course Description

ECE 411: Computer Organization and Design provides hands-on experience in computer architecture through the design and implementation of a complete RISC-V CPU. The course covers the fundamental concepts of computer organization and design from the ground up.

Topics Covered

• RISC-V instruction set architecture
• CPU pipelining and hazard management
• Memory hierarchy and organization
• Cache design and optimization
• I/O system design
• Reliability and fault tolerance
• Performance evaluation
• SystemVerilog hardware description

Key Projects

Implemented a complete RISC-V CPU in SystemVerilog with:

• Multi-stage pipeline
• Cache hierarchy
• Memory management unit
• I/O interfaces
• Performance optimization

Skills Gained

• CPU architecture design
• SystemVerilog HDL programming
• Pipeline implementation and optimization
• Memory system design
• Hardware debugging and testing
• Performance analysis
• Computer architecture principles

Course Description

ECE 420: Signal Processing Lab provides hands-on experience implementing signal processing algorithms on mobile platforms. The course focuses on real-time signal processing applications using Android development.

Topics Covered

• Real-time signal processing
• Android application development
• Digital filter implementation
• Audio signal processing
• Mobile sensor data processing
• Real-time algorithm optimization
• Mobile platform constraints
• DSP algorithm implementation

Key Projects

Developed Android applications implementing:

• Real-time audio processing
• Digital filtering techniques
• Signal analysis tools
• Mobile DSP algorithms

Skills Gained

• Android application development
• Real-time signal processing
• Mobile platform programming
• DSP algorithm implementation
• Performance optimization for mobile
• Audio processing techniques
• Practical DSP applications

Course Description

ECE 448: Introduction to Artificial Intelligence provides a comprehensive introduction to the fundamental concepts and techniques of artificial intelligence. The course covers both classical AI methods and modern deep learning approaches.

Topics Covered

• Search algorithms and heuristics
• Classification techniques
• Machine learning fundamentals
• PyTorch framework
• Computer vision applications
• Natural Language Processing (NLP)
• Neural network architectures
• AI problem-solving strategies

Key Projects

• Search algorithm implementations
• Machine learning classifiers
• Computer vision applications using PyTorch
• NLP text processing systems

Skills Gained

• AI algorithm design and implementation
• PyTorch deep learning framework
• Computer vision techniques
• NLP fundamentals
• Search and optimization algorithms
• Machine learning model development
• Python AI programming