Projects

Overview

This project focused on improving the security of the Open Energy Dashboard (OED), an open-source web application used to track energy consumption in different building using meter data, by identifying and fixing vulnerabilities in its codebase. The work involved reviewing existing implementations, applying secure coding practices, and integrating automated testing and CI/CD workflows to ensure vulnerabilities were properly mitigated and did not reappear.

Problem

Open-source applications like OED can contain security vulnerabilities that expose sensitive data or allow unauthorized access if not properly addressed. Without consistent testing, secure development practices, and automated validation, these issues can persist or be reintroduced over time. There was a need to systematically identify these weaknesses and ensure reliable, repeatable security checks.

Solution

To solve this, security vulnerabilities were analyzed and remediated by implementing secure code fixes and improving validation processes. Threat assessments were conducted to understand potential risks, and automated tests were developed using Node.js with Mocha and Chai to verify fixes. CI/CD pipelines were configured using GitHub Actions to automatically run tests and enforce code quality, while Docker was used to standardize the development and testing environment.

Impact

• • Reduced exploitable vulnerabilities
• • Improved system resilience
• • Strengthened security practices
• • Improved the overall security and reliability of the Open Energy Dashboard
• • Reduced risk of common vulnerabilities through secure coding practices
• • Ensured consistent validation of fixes using automated testing
• • Prevented regression of vulnerabilities through CI/CD pipeline integration

Tech/Concepts

Overview

This project simulates a personal local area network (LAN) entirely in Java by modeling real networking components such as hosts, switches, and routers. These components communicate across multiple machines to mimic how data travels through a real network from the data link layer (Layer 2) to the network layer (Layer 3). The system integrates key networking algorithms like Ethernet switching, IP forwarding, and distance vector routing to create a fully functional and distributed virtual network environment.

Problem

Understanding how real networks operate—especially how data moves across devices, subnets, and routing paths—can be difficult without hands-on experience. Many learning environments rely on theory or simplified simulations that don’t fully capture how networking protocols interact in a distributed system. There is a need for a practical way to visualize and implement how switching, routing, and packet forwarding work together across multiple machines.

Solution

To address this, the project builds a virtual LAN using Java, where each device (host, switch, router) runs as an independent process and communicates using UDP sockets. Switches implement the Ethernet Learning algorithm to manage MAC address mappings, while routers use IP forwarding and distance vector routing based on the Bellman-Ford algorithm to determine optimal paths. By combining these components, the system enables realistic packet transmission across multiple subnets with dynamic routing and automatic path discovery.

Impact

• • Demonstrated networking fundamentals
• • Simulated distributed systems
• • Provides hands-on experience with how real-world networks operate across multiple layers
• • Bridges the gap between theoretical networking concepts and practical implementation
• • Demonstrates how data flows through switches and routers in a distributed system

Tech/Concepts

Overview

This project implements a full Airline Booking System for Falcon Airlines using Java and MySQL. The application allows users to book flights, view reservations, and cancel bookings through a menu-driven interface, while all data is stored and managed in a relational database. It demonstrates how a Java application can connect to a remote database and perform full CRUD operations using JDBC.

Problem

For this class project, the goal was to better understand how applications interact with databases in a real-world scenario. While we had learned about SQL and Java separately, it can be hard to see how everything connects in a complete system. We needed a way to practice building something that actually stores, retrieves, and manages data while handling user input, rather than just working with small, isolated examples.

Solution

To address this, a Java-based application was developed that connects to a MySQL database using JDBC. The system provides two user modes: an employee interface for managing databases and tables, and a passenger interface for handling bookings. Core database operations such as creating tables, inserting bookings, viewing reservations, and deleting bookings are implemented through SQL queries, allowing seamless interaction between the application and the database.

Impact

• • Demonstrates practical use of database-driven application development
• • Provides hands-on experience with CRUD operations using JDBC
• • Strengthens understanding of relational databases and SQL queries
• • mproves skills in backend development and data management
• • Reinforces concepts of secure database connections and user input handling
• • Builds experience with modular and menu-driven application design

Tech/Concepts

Overview

This project implements a TCP-based client–server application in Java that provides a simple file service. The system allows a client to connect to a server and perform file operations such as uploading, downloading, listing, renaming, and deleting files. It demonstrates how reliable communication can be achieved using TCP sockets and how a custom protocol can be built on top of a byte-stream connection.

Problem

For this class project, the goal was to better understand how client–server communication actually works beyond just theory. While concepts like TCP and sockets were covered in class, it can be hard to visualize how data is sent, received, and processed between two programs. We needed a hands-on way to practice building a system where a client can send requests, a server can handle them, and both sides communicate using a defined structure.

Solution

To solve this, a Java-based client–server system was built using TCP sockets. A custom file transfer protocol was designed to define how commands and data are sent between the client and server. The client collects user input, formats it into requests, and sends it to the server, while the server processes commands and performs file operations. Responses and status codes are then sent back to the client to confirm success or failure, ensuring reliable and structured communication.

Impact

• • Demonstrated protocol design
• • Enabled reliable file transfers
• • Strengthened understanding of TCP communication and socket programming
• • Provided hands-on experience with client–server architecture
• • Demonstrated how custom protocols are designed and implemented
• • mproved skills in handling user input, parsing commands, and error handling
• • Showed how reliable data transfer works using TCP’s byte-stream model
• • Built experience with file I/O operations in a networked environment
• • Reinforced concepts of request-response communication between systems

Tech/Concepts

Overview

This project implements and compares several core CPU scheduling algorithms using Java to simulate how an operating system manages process execution. By modeling different scheduling strategies, the program calculates per-process waiting times and evaluates overall performance through average waiting time. The project highlights how scheduling decisions directly impact system efficiency and responsiveness.

Problem

For this class project, the challenge was understanding how different CPU scheduling algorithms actually behave beyond just reading about them. Concepts like waiting time, preemption, and time slicing can be confusing without seeing them in action. We needed a way to simulate real process scheduling so we could compare algorithms and clearly see how each one affects performance.

Solution

To address this, a Java-based simulation was created that reads process data from input files and applies multiple scheduling algorithms, including FCFS, SJF, Round Robin, and SRTF. The program tracks each process’s waiting time and calculates the average waiting time for each algorithm. By running the same workload across different strategies, the system makes it easy to compare performance and understand the trade-offs between them.

Impact

• • Strengthened understanding of operating system scheduling concepts
• • Provided hands-on experience comparing multiple CPU scheduling algorithms
• • Demonstrated the impact of scheduling strategies on waiting time and performance
• • Improved ability to analyze trade-offs between fairness and efficiency
• • Built experience working with simulations and algorithm implementation
• • Reinforced concepts like preemption, time slicing, and process management
• • Enhanced problem-solving and analytical thinking skills

Tech/Concepts

Overview

This project is a two-player Connect 4 game built in Java that features an AI opponent using the Minimax algorithm with Alpha-Beta pruning. The AI evaluates possible future game states and selects the best move based on optimal play, while depth limiting ensures the program runs efficiently. The project demonstrates key concepts in artificial intelligence, game theory, and decision-making algorithms.

Problem

For this class project, the challenge was understanding how AI actually makes decisions in games. While concepts like Minimax and game trees were covered in class, it’s hard to fully grasp how an algorithm evaluates moves and predicts outcomes without building one yourself. We needed a way to implement an AI that could simulate future moves and make smart decisions in a competitive game setting.

Solution

To solve this, a Connect 4 game was developed with an AI powered by the Minimax algorithm. The AI recursively explores possible moves, treating one player as the maximizer and the other as the minimizer. Alpha-Beta pruning is used to eliminate unnecessary branches of the game tree, improving performance and allowing deeper searches. A depth limit and heuristic evaluation function ensure the AI can make strong decisions without excessive computation.

Impact

• • Strengthened understanding of AI decision-making and adversarial search
• • Demonstrated how Minimax simulates future game states to choose optimal moves
• • Showed the effectiveness of Alpha-Beta pruning in improving performance
• • Built experience with recursive algorithms and tree-based problem solving
• • Reinforced concepts in game theory and optimal strategy
• • Improved ability to design and evaluate heuristic functions
• • Provided hands-on experience developing an intelligent game agent

Tech/Concepts