TASK 2 - MERCHANDISE APP

Project Overview:
For this project, I will be creating a Taylor Swift merchandise app. The app will allow users
to browse and purchase various merchandise items related to Taylor Swift, including
clothing, accessories, albums, and more. Users will be able to create accounts, log in, add
items to their shopping cart, and complete purchases securely. Additionally, the app will
feature user profiles where users can view their order history and manage their account
settings.
To create this solution, I will be using Xcode as the development environment, leveraging
either SwiftUI or UIKit for building the user interface, depending on the target platform (iOS
or macOS). I will also integrate backend functionality to handle user authentication, product
listings, shopping cart management, and order processing. Payment processing will be
handled through integration with a secure payment gateway such as Stripe or PayPal.

Resources Needed:
1. Xcode: Integrated development environment (IDE) for building iOS and macOS
applications.
2. Swift programming language: Used for writing the software code.
3. SwiftUI or UIKit: Frameworks for designing the user interface.
4. Backend server (optional): For handling user authentication, product listings, and
order processing.
5. Payment gateway integration documentation: Resources for integrating a secure
payment gateway for processing transactions.
6. Tutorials and documentation: Online resources and tutorials for learning and
implementing specific features and functionalities required for the app.

Design Specifications:
For the User:
1. User-friendly interface: The app should have an intuitive and visually appealing user
interface, allowing users to easily navigate through merchandise listings, add items to
their cart, and complete purchases.
2. Secure authentication: Implement a secure authentication system to ensure user
accounts are protected and only accessible by authorized users.
3. Smooth checkout process: Ensure a seamless checkout process with clear steps for
entering shipping and payment information, as well as order confirmation.

For the Developer:

 1. Modular code architecture: Implement a modular code architecture to ensure
scalability and maintainability of the app codebase, making it easier to add new
features or make changes in the future.
2. Error handling: Implement robust error handling mechanisms throughout the app to
gracefully handle unexpected scenarios and provide informative error messages to
users.
3. Documentation: Document the code thoroughly, including comments and
documentation files, to aid in understanding and maintaining the codebase.
Additionally, create user documentation to guide users on how to use the app
effectively.

Quality Assurance Criteria:

Efficiency:
 Response Time: Measure the time taken by the app to respond to user interactions
such as loading product listings, adding items to the shopping cart, and completing
purchases. Aim for fast response times to ensure a smooth user experience.
 Resource Usage: Monitor the app's resource usage, including CPU, memory, and
network bandwidth, to ensure efficient utilization and avoid excessive consumption
that could degrade performance.

Integrity:
 Data Integrity: Implement data validation mechanisms to ensure that user input and
app-generated data are accurate and consistent throughout the app. Verify data
integrity during user registration, login, and transaction processing.
 Security Measures: Conduct security audits to identify and address potential
vulnerabilities such as data breaches, unauthorized access, and data manipulation.
Implement encryption techniques and secure authentication mechanisms to safeguard
user data and prevent unauthorized access.

Reliability:
 Error Handling: Implement robust error handling mechanisms to gracefully handle
unexpected scenarios and prevent app crashes. Log errors and exceptions
systematically to facilitate troubleshooting and debugging.
 Crash Rate: Monitor the app's crash rate by collecting crash reports and analytics
data. Aim for a low crash rate to ensure a reliable user experience and minimize
disruptions for users.
Usability:
 User Interface Design: Evaluate the user interface design for clarity, consistency, and
intuitiveness. Conduct usability testing with target users to gather feedback on
navigation flows, button placements, and overall usability.
 Accessibility: Ensure that the app is accessible to users with disabilities by adhering
to accessibility standards such as VoiceOver support, high contrast modes, and
customizable text sizes. Conduct accessibility audits to identify and address potential
barriers to accessibility.

Accuracy:
 Product Information: Verify the accuracy of product listings, including images,
descriptions, prices, and availability. Regularly update product information to reflect
changes in inventory and pricing accurately.
 Transaction Processing: Validate the accuracy of transaction processing, including
order placement, payment processing, and order fulfillment. Conduct end-to-end
testing of the checkout process to ensure that orders are processed accurately and that
users receive timely notifications and updates on their orders.
These measurable criteria will be continuously evaluated throughout the project to ensure that
the app meets quality standards and user requirements effectively. Regular testing, feedback
gathering, and iterative improvements will be essential to maintaining high-quality standards
throughout the development lifecycle.

PESUDOCODE – Add To Cart

FUNCTION addCartItem(item, quantity):
IF cartContainsItem(item)
updateCartItemQuantity(item, quantity)
ELSE:
newItem = createCartItem(item, quantity)
cart.addItem(newItem)
END IF
END FUNCTION

FUNCTION cartContainsItem(item):
FOR each cartItem IN cart:
 IF cartItem.item == item:
RETURN TRUE
END IF
END FOR
RETURN FALSE
END FUNCTION

FUNCTION updateCartItemQuantity(item, quantity):

FOR each cartItem IN cart:
IF cartItem.item == item:
cartItem.quantity += quantity
RETURN
END IF
END FOR
END FUNCTION

FUNCTION createCartItem(item, quantity):

newItem = {
item: item,
quantity: quantity
}
RETURN newItem
END FUNCTION

Explanation:
 The addCartItem function is responsible for adding items to the shopping cart. It first
checks if the item already exists in the cart using the cartContainsItem function. If the
item exists, it updates the quantity using the updateCartItemQuantity function. If the
item does not exist, it creates a new cart item using the createCartItem function and
adds it to the cart.
 The cartContainsItem function checks if the item is already present in the cart by
iterating through each item in the cart and comparing it with the given item.
  The updateCartItemQuantity function updates the quantity of an existing item in the
cart by iterating through each item in the cart and finding the matching item. If found,
it updates the quantity.
 The createCartItem function creates a new cart item object with the given item and
quantity and returns it.

Errors:
During the development of the Taylor Swift merchandise app, we encountered various errors
and bugs, spanning from logic errors to runtime errors. One prevalent issue was logic errors,
particularly in calculating total prices within the shopping cart. Initially, incorrect arithmetic
operations led to inaccurate totals being displayed to users. To resolve this, extensive testing
was conducted, including adding different items with various quantities to the cart and cross-
verifying the calculated totals against manual calculations. Additionally, collaborative code
reviews with peers played a crucial role in identifying and rectifying these erroneous
calculations promptly.

Runtime errors were also encountered, often occurring when attempting to access null objects
or out-of-bounds array indices, resulting in app crashes. To address these runtime errors,
defensive programming techniques were employed. This involved implementing null checks
and boundary checks before accessing objects or array elements. Furthermore, unit tests were
developed to simulate different scenarios and catch potential runtime errors early in the
development process, thereby enhancing the robustness of the codebase.

Another category of issues involved user interface bugs, such as misaligned elements or
overlapping views, which surfaced during UI testing across various device sizes and
orientations. Responsive design principles were applied to ensure the app's user interface
adapts correctly to different screen sizes and orientations. Adjustments were made to Auto
Layout constraints, and UI elements were resized or repositioned as necessary. Continuous
testing on diverse devices and screen sizes helped in identifying and rectifying these UI bugs
effectively.

In terms of testing strategies, breakpoints were instrumental in pausing the execution of code
at specific points, allowing for the inspection of variables and analysis of program state to
pinpoint the root cause of errors and bugs. Additionally, the strategic placement of debug
print statements throughout the code aided in tracing the flow of execution and identifying
potential issues, especially within complex algorithms or functions. Furthermore, unit testing
using XCTest framework helped in testing individual components and functions in isolation,
ensuring each part of the app behaved as expected. Lastly, user acceptance testing (UAT)
involving beta testing with a small group of users provided valuable feedback on usability,
functionality, and performance. User feedback was collected, analyzed, and used to prioritize
bug fixes and enhancements, ultimately enhancing the quality and reliability of the Taylor
Swift merchandise app.