Chapter 3

Methodology
3.1 Design Approach
The design approach adopted for the development of the Offline
Spending Tracker Application for Mobile is rooted in the principles of
Object-Oriented Design (OOD). Object-Oriented Design provides a
paradigm for organizing and structuring software code based on the
concept of "objects," which encapsulate data and behavior, promoting
modularity, reusability, and maintainability.

In an Object-Oriented approach, the application is conceptualized as a

collection of interacting objects, each representing a real-world entity or
concept within the system. Objects encapsulate data and the functions
that operate on that data, fostering a modular and compartmentalized
structure. This design philosophy aligns with the nature of the Offline
Spending Tracker, where different entities such as expenses, budget
items, and user profiles can be viewed as distinct objects with unique
attributes and behaviors.

A key idea in object-oriented design is packaging, which emphasizes the

grouping of data and the operations performed on that data into a single
entity, or object. By limiting access to internal details, this encapsulation
improves data security while also enabling a clear separation of concerns,
which improves system maintainability and comprehension.
Inheritance, another key principle, allows for the creation of a hierarchy
of classes where a new class can inherit attributes and behaviors from an
existing class. This feature promotes code reuse and establishes a clear
relationship between different components of the application. For
instance, the design may include a generic "Expense" class from which
more specific expense types, such as "Groceries" or "Entertainment," can
inherit common properties.
Polymorphism, the third pillar of Object-Oriented Design, enables the use
of a single interface to represent different types of entities. This flexibility
is particularly valuable in a spending tracker application, where various
financial transactions may share common functionalities while exhibiting
specific behaviors unique to their context.
By adopting an Object-Oriented Design approach, the Offline Spending
Tracker Application benefits from improved code organization,
reusability of components, and ease of maintenance. The design
encapsulates the complexity of the application within well-defined
objects, making it more adaptable to future enhancements or
modifications. The principles of Object-Oriented Design lay a robust
foundation for the subsequent stages of development, ensuring that the
application is not only functional but also scalable and maintainable in
the long run.

3.2 Design Details

In the design phase of the Offline Spending Tracker Application for
Mobile, the focus was on a meticulous breakdown of the system into key
components, each serving distinct functionalities. The User Interface (UI)
component was designed with React Native and Expo, for prioritizes
usability and simplicity. While the Budgeting component allows users to
build and manage budget lists, the Expense Tracking component handles
the logic of recording and classifying spending. The Database Interaction
component ensures seamless communication with the Realm Database,
incorporating robust controls and strings for data integrity. Screen
transitions are controlled using React Navigation, while a centralized
state is maintained with Redux State Management. Enhancing modularity
and maintainability, the method made extensive use of Object-Oriented
Design principles including inheritance and encapsulation. These design
details lay the groundwork for a well-structured and scalable application,
setting the stage for the subsequent implementation phase where the
envisioned features will come to fruition.

3.3 Data model and and Development Environment

In crafting the data model for the Offline Spending Tracker Application, a
dynamic and versatile structure is meticulously designed to encompass
three core entities—'Expense,' 'Budget,' and 'User'—each encapsulating
vital attributes, and this intricate data model seamlessly converges with
the Realm Database schema, which mirrors its adaptability, allowing for
efficient storage, retrieval, and modification of data, with tables such as
'Expense,' 'Budget,' and 'User' interconnected to form a cohesive
structure, fostering a responsive and scalable foundation for the
application, and this symbiotic relationship between the data model and
database schema, rooted in the principles of the Agile development
model, not only ensures the effective tracking of expenses, personalized
budget management, and user-centric functionalities but also facilitates
seamless iterations and enhancements, embodying the core philosophy of
adaptability and continuous improvement inherent in the Agile
methodology.
The Agile development model necessitates a set of robust and
collaborative tools to support continuous integration, testing, and
delivery. The development environment is carefully selected to facilitate
seamless collaboration among team members and enable rapid iteration.

Version Control: Git

Description: Git is a distributed version control system that enables
collaborative code management. It allows multiple developers to work on
the project simultaneously, keeping track of changes, and providing a
mechanism for integrating new features.

Significance: In the Agile model, where collaboration is paramount, Git

ensures that developers can work on different parts of the codebase
independently. It also facilitates version tracking, enabling the team to
roll back to previous versions if needed, and supports concurrent
development without conflicts.

Testing: Android Studio

Description: Android Studio are testing tools specifically tailored for

React Native applications. Android Studio is a testing framework, and
testing utility, together allowing for unit testing of individual
components, ensuring their reliability and functionality of android
application.

Significance: Automated testing is a fundamental aspect of Agile

development. Android Studio contribute to the reliability of the codebase
by allowing developers to write and execute tests that ensure each
component works as expected. This early identification of issues supports
the Agile principle of delivering functional increments consistently.

Development Environment: Visual Studio Code

Description: Visual Studio Code is an integrated development

environment (IDE) chosen for its lightweight nature, extensibility, and
strong support for React Native development. It provides features like
syntax highlighting, code completion, and debugging tools.

Significance: In an Agile development environment, the choice of IDE is

critical. Visual Studio Code streamlines the coding process, allowing
developers to work efficiently and adapt to changing requirements
seamlessly. Its extensibility ensures compatibility with various plugins
and extensions, enhancing the overall development experience.

In summary, these tools and the development environment collectively

support the Agile development model for the Offline Spending Tracker
Application. They foster collaboration, streamline development
workflows, and ensure adaptability, ultimately contributing to the
creation of a responsive and user-centric mobile application. This holistic
approach to tooling underscores the commitment to Agile principles,
facilitating the iterative and collaborative development of the Spending
Tracker application.

3.4 Technology Stack Selection:

In shaping the technological foundation of the Offline Spending Tracker
Application, a meticulous selection of technologies has been made to
ensure a seamless and robust development process.

React Native: The heart of the technology stack is React Native, chosen
as the primary framework for developing the mobile app. Recognized for
its capacity to enable cross-platform development without compromising
performance, React Native is the linchpin that ensures our application
operates seamlessly on both iOS and Android devices. This choice not
only expedites development but also guarantees a consistent and high-
quality user experience across diverse platforms.

Expo: To improve the development workflow, Expo, a complete toolkit

built around React Native, has been seamlessly integrated with React
Native. Expo offers a number of useful features, such as an integrated
development server, streamlined build procedures, and effective
debugging tools. Its incorporation fits in perfectly with the project's
dedication to effectiveness and the simple creation of a strong mobile
application.

Redux: To fortify the application's data handling and management

capabilities, the technology stack incorporates Redux, a predictable state
container. These choices stem from the project's dedication to crafting an
architecture that not only operates efficiently but also ensures
unparalleled data integrity and security.Redux establishes a structured
approach to managing the application's state, bolstering the reliability and
maintainability of the Offline Spending Tracker. This thoughtful selection
of technologies reflects a strategic approach to building a mobile
application that excels in performance, development efficiency, and the
secure management of financial data.

3.5 Database Design:

The database design for the Offline Spending Tracker Application is a

critical aspect of ensuring efficient data storage, retrieval, and
manipulation. This section details the key components of the database
design, covering Entity-Relationship (ER) diagrams, normalization,
database manipulation techniques, and the implementation of database
connection controls and strings.

3.5.1 ER Diagrams:
Entity-Relationship (ER) diagrams serve as a visual representation of the
relationships between different entities in the database. For the Offline
Spending Tracker, the ER diagram depicts the connections among the
three primary entities: 'Expense,' 'Budget,' and 'User.' Relationships are
established to reflect associations such as each 'Expense' being linked to a
specific 'User' and 'Budget.' Attributes of each entity, such as expense
amount, date, and category, are outlined in the ER diagram. This visual
representation aids in understanding the relational structure, ensuring data
integrity and facilitating effective communication between developers
and stakeholders.

3.5.2 Normalization:
Normalization is a crucial database design concept that ensures the
efficient organization of data within tables, minimizing redundancy and
dependency. In the context of the Offline Spending Tracker Application,
normalization is applied to the database schema to enhance data integrity,
simplify maintenance, and support the dynamic nature of expense
tracking and budget management.
The database for the Spending Tracker consists of three main entities:
'Expense,' 'Budget,' and 'User.' Each of these entities has specific
attributes capturing relevant information. Normalization is applied to
these entities to eliminate redundancy and improve overall database
performance.

Expense Entity:
The 'Expense' entity, responsible for storing information about each
spending transaction, is normalized to avoid duplicate entries and
improve data consistency. Attributes such as 'amount,' 'date,' 'description,'
and 'category' are organized efficiently within the 'Expense' table.

Budget Entity:
The 'Budget' entity, which represents the user's budgeting plan, is
designed with normalization principles in mind. It includes attributes
such as 'budgeted categories,' 'allocated amounts,' and 'spending limits.'
Normalization ensures that budget-related data is logically organized,
reducing the likelihood of data anomalies.

User Entity:
The 'User' entity captures information about application users, including
profiles, preferences, and settings. Normalization in this context ensures
that user-specific data is stored in a structured manner, enhancing the
maintainability and scalability of the database.
Relationships:
Relationships between these entities are established based on foreign key
associations. For example, each 'Expense' is linked to a specific 'User' and
'Budget.' This ensures that the data is interconnected, supporting the
application's functionality, such as associating expenses with the
respective user and budget.
Advantages of Normalization in the Spending Tracker Application:

Reduced Redundancy:

Normalization eliminates duplicate data entries, reducing the risk of

inconsistencies and making the database more efficient in terms of
storage.

Improved Data Integrity:

By organizing data into separate tables and establishing relationships,
normalization ensures that the data is accurate and reliable, supporting the
application's ability to track and manage expenses effectively.

Adaptability to Changes:
The Agile development model emphasizes adaptability, and
normalization supports this by providing a flexible structure that can
accommodate changes and updates to the application's features without
major disruptions to the database schema.

Simplified Maintenance:
Normalized databases are generally easier to maintain. When
modifications or additions are necessary, developers can make changes to
specific tables without affecting the entire database, supporting an agile
and iterative development approach.
In summary, normalization is a foundational aspect of the database design
for the Offline Spending Tracker Application. It ensures that the data is
organized efficiently, relationships are well-defined, and the database
structure is adaptable to changes, aligning with the Agile model's
principles of flexibility and responsiveness. This approach to
normalization contributes to the overall effectiveness and reliability of the
Spending Tracker's database, supporting its core functionality of tracking
expenses and managing budgets.

3.5.3 Database Manipulation:

Database manipulation is a critical aspect of the Offline Spending Tracker

Application, enabling the seamless interaction between the application
and the underlying database. In this context, database manipulation
encompasses a set of techniques and operations that facilitate the
addition, retrieval, modification, and deletion of data within the 'Expense,'
'Budget,' and 'User' entities.

Inserting Data:
The process of inserting data involves adding new entries to the database.
In the Spending Tracker, this corresponds to capturing new expenses,
creating budget plans, and registering user profiles. Realm instance
statements are employed to add records to the respective tables, ensuring
that new data is appropriately incorporated.
Retrieving Data:
Retrieving data is essential for displaying information within the
application. For instance, when a user wants to view their expense history
or budget details, Realm select statements are utilized to fetch the
relevant data based on specified criteria.

Updating Data:
The ability to modify existing records is crucial for users to accurately
reflect changes in their spending or adjust budget allocations. Update
statements are employed to modify specific attributes within a record.

Deleting Data:
Deleting data allows users to remove outdated or unnecessary
information from the database. This is achieved using delete statements,
ensuring that the data remains accurate and relevant.

Transaction Management:
To maintain data integrity, the Spending Tracker implements transaction
management. This ensures that a series of operations either complete
successfully or leave the database in a consistent state. For instance, when
transferring an amount from one budget category to another, a transaction
is utilized to ensure both debit and credit operations occur atomically.

Error Handling:
Robust error handling mechanisms are implemented to manage
exceptional scenarios, ensuring that the application gracefully handles
errors and provides meaningful feedback to users.
Asynchronous Operations:
Asynchronous database operations are employed to prevent the
application from becoming unresponsive during time-consuming tasks,
enhancing the user experience.

Database manipulation in the Offline Spending Tracker Application

involves a set of carefully orchestrated operations that allow users to
interact with their spending data and budgets. Whether inserting new
expenses, retrieving historical data, updating budget allocations, or
deleting outdated records, these manipulation techniques are fundamental
to the application's functionality, supporting an intuitive and responsive
user experience.

3.5.4 Database Connection Controls and Strings:

Establishing a secure and efficient connection between the Offline
Spending Tracker Application and the underlying Realm Database is
paramount for the application's functionality and data integrity. This
section outlines the controls and connection strings implemented to
ensure a robust and dependable interaction with the database.

Connection String:
A connection string serves as a key component in defining the parameters
needed to establish a connection to the Realm Database. It includes
essential information such as the database location, authentication
credentials, and other configuration details. The connection string is
carefully crafted to ensure a secure and accurate link between the
application and the database.
In the context of the Offline Spending Tracker, the connection string is
configured to connect to the Realm Database securely, safeguarding
sensitive user information and ensuring that data communication occurs
seamlessly.

Connection Controls:

1. Encryption and Authentication:

The connection controls enforce robust encryption and authentication
measures to secure the data transmitted between the application and the
database. This involves using secure protocols such as TLS/SSL to
encrypt communication channels, preventing unauthorized access to
sensitive user data.

2. Credential Management:
User credentials, including usernames and passwords, are securely
managed within the application. The connection controls ensure that only
authenticated users with valid credentials can access and manipulate data
in the Realm Database.

3. Connection Pooling:
Connection pooling is implemented to efficiently manage and reuse
database connections, reducing the overhead of establishing a new
connection for each user interaction. This enhances the application's
performance and responsiveness, especially in scenarios where multiple
users are concurrently accessing the database.

Timeouts and Retries:

Connection controls include timeout settings and retry mechanisms to
handle network fluctuations or temporary unavailability of the database
server. This ensures that the application gracefully handles connection
issues and attempts reconnection when necessary.

The Offline Spending Tracker Application prioritizes the implementation

of robust database connection controls and strings to establish a secure,
reliable, and efficient link to the Realm Database. By enforcing
encryption, authentication, connection pooling, timeouts, and retries, the
application ensures the integrity of user data and adheres to the Agile
model's principles of security, adaptability, and responsiveness.