Coding Portfolio
Project # 1: Campus Parking System
The Campus Parking System is a C-based application designed to simulate parking management operations within a university campus environment, emphasizing efficient resource tracking and memory-safe system design. The program models multiple parking garages and registered vehicles through dynamically allocated data structures, allowing the system to respond to real-time changes in parking availability and vehicle movement. User interaction is handled through a command-driven interface that supports vehicle registration, parking and departure operations, and utilization reporting across garages. Particular attention was given to precise memory allocation and deallocation practices, with all data structures sized exactly to their requirements in order to minimize waste and prevent memory errors. The project applies advanced C programming concepts such as pointer arithmetic, multi-dimensional dynamic arrays, and structured data organization to solve a realistic infrastructure management problem. Throughout development, the system was tested for memory safety using industry-standard debugging tools, ensuring that all allocated memory is properly released and that no leaks occur during execution. This project demonstrates a strong understanding of low-level programming, system resource management, and modular design in C while addressing a practical and relatable problem domain.
Project # 2: Traffic Fine Management System (BST)
The Traffic Fine Management System is a C-based application that simulates the administration and tracking of traffic violations using a Binary Search Tree (BST) as its core data structure. The system organizes vehicle owner records hierarchically, allowing fine information to be stored, retrieved, and updated efficiently through recursive tree operations. Users interact with the application via a command-line interface that supports inserting new records, modifying fine balances, searching for specific vehicle owners, and generating analytical information such as aggregate fine totals and tree metrics. The project emphasizes correct recursive logic, pointer-based tree manipulation, and disciplined memory management practices, including proper post-order deallocation of all dynamically allocated nodes. Average-case logarithmic time complexity is achieved for insertion and lookup operations, demonstrating the performance benefits of tree-based data organization. The application’s structure separates tree logic from user interaction and business rules, improving maintainability and clarity. This project illustrates a practical application of data structures and algorithms commonly studied in computer science curricula while reinforcing foundational skills in recursion, abstraction, and efficient data management.
Project # 3: Nile Dot Com E-Store Simulation (Event-Driven GUI)
The Nile Dot Com E-Store Simulation is a Java-based standalone application that models the core functionality of an online retail system through event-driven programming and object-oriented design principles. Developed using Java Swing for the graphical interface, the project simulates common e-commerce workflows such as browsing inventory, adding items to a shopping cart, processing customer orders, and recording completed transactions. The application follows a structured separation between the user interface and underlying business logic, allowing inventory data, order calculations, and transaction processing to be managed independently from visual components. User interactions such as button clicks and form submissions trigger event handlers that update application state in real time, providing an interactive and responsive experience. Persistent data storage is implemented through structured file input and output operations, ensuring that transaction records and inventory changes are preserved across sessions. Particular emphasis was placed on maintaining data integrity, validating user input, and handling exceptional conditions gracefully to prevent invalid operations or application crashes. This project demonstrates practical experience with GUI development, event handling, file management, and modular Java design while reflecting a realistic simulation of online retail systems commonly studied in undergraduate computer science coursework.
Project # 4: Train Yard Dispatch Simulator
The Train Yard Dispatch Simulator is a concurrent Java application that models the coordinated movement of multiple trains through a shared rail yard using synchronization mechanisms inspired by Precision Scheduled Railroading concepts. Each train is executed as an independent task managed by an ExecutorService with a fixed thread pool, requiring exclusive access to a specific sequence of switches before entering the yard. To prevent deadlock, the simulator enforces a strict lock acquisition order using ReentrantLock objects, requiring trains to release all previously acquired locks and wait before retrying if any required switch is unavailable. The yard configuration and fleet schedule are loaded from external CSV files, allowing the simulation behavior to be driven entirely by input data rather than hardcoded logic. Trains whose inbound and outbound routes are not represented in the yard configuration are placed on permanent hold, accurately reflecting invalid routing scenarios. The simulator produces a detailed execution log that traces lock acquisition attempts, waiting behavior, dispatch events, and a final summary of train statuses upon completion. This project demonstrates applied knowledge of multithreading, concurrency control, deadlock avoidance strategies, and real-world synchronization challenges in Java, aligning closely with upper-level coursework in operating systems and concurrent programming.