In mobile application (app) development, one of the main aims of developers is to provide an interactive user experience. For this purpose, developers must follow certain common architectural principles to ensure that their app satisfies the quality and market standards.
We should design mobile apps' architecture so that they are scalable. At the same time, we need to provide robustness to the system without further increasing its complexity.
Some of the architectural principles for mobile app development are as follows:
It is a common practice among developers to write all the app's code in a single file or class. This makes the program non-modular. The classes defined should only contain the relevant data. We call this the separation of concerns. For instance, the Activity class should only contain the UI, the logic that handles the UI, and the operating system interaction. At one instance, this class should not contain any other process data when a certain process is being executed.
Let's suppose there are running processes that overwhelm the mobile's operating system. Then, the operating system would remove the least used process memory block, or the one with the least priority, from memory. However, this might also remove part of the code the shared memory space stores for that process and corrupt the application.
So, we should write the app code such that if we need to remove it from memory, we remove all the application data as a whole. This way, when we fetch this data again, if required, we can receive all the app data. Thus, we prevent the app from getting corrupt.
If we make the program modular, we would also make testing the code easier. So, to ensure a greater user experience, we should always minimize the dependency on the application program.
These data models contain the data of the app and don't depend on the UI and the other components created in the application. Thus, they have no connection with the application's components.
However, the operating system can still remove its processes from the memory if required. This time, if we use persistent data models, the application's data doesn't corrupt when the operating system removes its data from memory. This is because the data models are independent of the app and have their data preserved, which results in the smooth working of the app if we fetch it again. Moreover, the application becomes more robust because persistent data models are less often modified.
Free Resources