CS-499 ePortfolio

🎯 Software Design and Engineering Enhancement

View the Design Enhancement Repository

To improve the structure and maintainability of my food inventory application, I focused on applying software design and engineering principles that helped me clean up and organize the code. In the beginning, most of the functionality was packed into a single activity. This made the app harder to manage, especially as I started adding more features. Everything from handling data to updating the user interface and processing input was all in one place, which created a lot of unnecessary complexity. I decided to refactor the project by separating the different responsibilities across multiple classes. I created helper classes to manage database operations, which allowed me to move those tasks out of the main activity. This made the code easier to read, troubleshoot, and update when needed. It also gave the project a much better structure that can support future improvements without causing conflicts or confusion. One of the biggest improvements I made was updating the user interface. I redesigned the way inventory items are displayed by creating a custom adapter. This allowed me to have full control over how each item appears in the list. Now, each item shows a clear name and quantity label in a consistent format, making the display cleaner and easier for users to understand. I also cleaned up the layout files, renamed UI elements for better clarity, and made sure that all screens followed a consistent design. Instead of repeating code for common elements, I created reusable components that handle shared tasks. This not only reduced the amount of code I had to write but also made the app easier to maintain. If I ever need to change something about how an item is shown or how input is handled, I only have to update it in one place. These changes have made a big difference. The app is more stable, easier to work with, and better prepared for future features. By organizing my code and reworking the user interface, I was able to turn a messy and fragile project into a cleaner and more professional application.

⚙️ Algorithms and Data Structures Enhancement

In the original version of the application, I used basic linear search methods to filter and sort inventory items. This worked fine when the inventory was small, but as the number of items grew, the app started to slow down. Load times increased, and the overall performance became less reliable, especially when working with a larger dataset. To improve efficiency, I focused on optimizing the way expiration dates were checked. I reorganized the inventory data by sorting items based on their expiration dates. This allowed the app to scan only the items that were most relevant instead of looping through everything. I applied a sliding window approach to limit the focus to items that were about to expire, which helped cut down on unnecessary processing. I also added a HashMap to organize items based on key properties like category and name. This gave the application the ability to retrieve specific items much faster using constant time lookups. Instead of searching through the entire list every time, the app could now jump straight to what it needed. These updates significantly improved the performance of the app. Load times dropped, and users can now filter and sort their inventory quickly, even when managing a large number of items. The app feels faster and more responsive, and the improvements made it much easier to scale in the future without sacrificing user experience.

🗄️ Database Enhancement

To strengthen the data layer of the application, I redesigned the SQLite database to support better organization, accuracy, and long term growth. The original setup stored category names and units directly inside the main inventory table. This approach made it easy to start with, but as the data grew, it caused repeated values and made the system more prone to mistakes and inconsistencies. To improve this, I separated the categories and units into their own tables. I then connected them to the inventory table using foreign keys. This change helped organize the data more clearly and made the relationships between items much easier to manage. By removing the repeated fields and relying on linked tables, I was able to reduce redundancy and make updates simpler and more accurate. I also added rules to protect data integrity and set up indexes to improve the speed of common searches. These updates made it easier and faster to retrieve information from the database. As a result, the app now performs better and is built on a much more stable and flexible foundation. These changes prepare the application for future features and allow it to grow without running into performance issues or data errors.