[25] Systems Design - Chapter 2

Question 1

Challenges mobile development face?

Answer 1

• Hardward diversity
• Platform and OS version differences
• Limited resources: batterry, CPU, GPU, storage
• Security and privacy expectations

Question 2

NFR - Non functional requirements Mobile apps need?

Answer 2

1. Performance -> ensures responsiveness
2. Accessibility -> support for users with disabilities.
3. Internationalization -> Multiple languages, local specific formats and cultural variation
4. Security
5. Privacy
6. Battery Optimization
7. Matainability -> code and architecture are easy to change, matain, debug and test
8. Availability -> keep the system working with little downtime even where there is failures.
9. Portability -> Enables the app to run across devices, OS versions, and platforms with minimal changes.

Question 3

Factors affecting performance?

Answer 3

Hardware diversity
Affects rendering speed, computation time, and memory limits
Platform differences
Causes API inconsistencies, OS behavior changes, and compatibility issues
Limited resources
Forces optimization for memory, battery, and background execution
Connectivity variability
Impacts load times, data requests, and offline functionality
Third-party dependencies
Introduces latency, increases app size, and consumes additional resources
Architectural decisions
Influences rendering logic, reactivity, and responsiveness based on chosen patterns
Evaluation oversights
Leads to incomplete optimization when key metrics like memory, latency, or UI interactivity are ignored

Question 4

What to consider for Accessibility?

Answer 4

Visual
Visual impairment, low vision
Ensuring full screen reader support, meaningful alt text, logical focus order, and proper label semantics
Hearing
Hearing impairment, hard of hearing
Providing visual alternatives for audio cues, captions for videos, and non-reliant sound alerts
Motor
Limited dexterity, tremors
Designing with large touch targets, avoiding time-sensitive gestures, and enabling full keyboard or switch navigation
Cognitive
Learning, memory, and attention limitations
Simplifying navigation, avoiding overwhelming UI elements, and offering guided interaction flows

Question 5

What is Internatioliazation (i18n)?

Answer 5

Internationalization is the design-time preparation that makes a system capable of adapting to different regions without rewriting the core codebase each time.

Question 6

What things to consider to support internationalization?

Answer 6

• Using layout strategies that can support both left-to-right (LTR) and right-to-left (RTL) languages.
• Avoiding hardcoded text and instead referencing keys in translation files.
• Designing for text expansion and different font rendering.
• Enabling proper date, time, and currency formatting via locale-aware utilities.
• Ensuring back-end services and APIs can serve locale-specific content when needed.

Question 7

What is Localization (L10n)?

Answer 7

Localization adapts an internationalization-ready system to a specific locale. This includes translating text, adjusting visuals, changing icons or colors for cultural appropriateness, and formatting data like prices or dates.

Question 8

How security (should) operates in the following layers:
- Application Layer
- Network Layer
- Device / OS layer
- User Interation

Answer 8

Question 9

Difference between security and privacy

Answer 9

Unlike security, which focuses on keeping intruders out, privacy is about limiting what even authorized parties can do with data.

Question 10

How to optimize Battery Live?
In:
Background Processes
Network Usage
Sensor Control
UI Choices
Platform Integration

Answer 10

A battery-conscious mobile System Design makes thoughtful decisions around:

• Background processes: Avoid polling and frequent wakeups. Use system-provided or OS schedulers like WorkManager (Android) or BackgroundTasks (iOS) to batch work efficiently.
• Network usage: Bundle API calls where possible and defer non-critical ones when on low power, or bad networks.
• Sensor control: GPS, accelerometer, and camera access must be minimized and tightly scoped.
• UI choices: Limit heavy animations or frame redraws; respect battery-saving mode preferences.
• Platform integration: Make use of energy diagnostics from Xcode Instruments or Android Profiler during testing.

Question 11

How to ensure Maintainability?

• Architecture
• Modular code base
• Consistent Naming and structure
• Documentation

Answer 11

• Clear architectural patterns: MVP, MVVM, and other mobile-centric architectures create separation of concerns that reduce entanglement. We have discussed them in detail in the next chapter.
• Modular codebase: Components (e.g., login, feed, payment) should be independently testable and swappable.
• Consistent naming and structure: Predictability makes it easier to locate, reuse, or rewrite code, especially when switching platforms.
• Documentation: We should have comprehensive documentation, not just for developers but also for designers, testers, and translators working in and around the system.

Question 12

How to ensure availability?

• Cache
• Retry logic
• Background resiliency
• Progressive loading

Answer 12

• Graceful degradation: We should cache data when online and serve it when offline. We should also notify the user only when necessary; don’t send alerts for transient issues.
• Retry logic and state recovery: We should avoid lost actions by queueing user requests locally (e.g., messages, form submissions) and sync them when conditions improve.
• Background resiliency: We should use OS-supported mechanisms (like WorkManager, BackgroundTasks) to resume critical tasks even after interruptions.
• Progressive loading: We should prioritize visible data first (e.g., headlines over thumbnails), so the app feels responsive even when the bandwidth is limited.

Question 13

What is portability?

Answer 13

Portability ensures that our mobile system can be extended, reused, or adapted across platforms without significant rework

Question 14

How to achieve Portability?

Answer 14

• Cross-platform code reuse: Using shared logic (via Kotlin Multiplatform, Flutter, or React Native) reduces duplication and simplifies updates.
• Adaptive layouts: Designing UI that scales across screen sizes, phones, tablets, and foldables prevents fragmentation, and avoids rebuilding for each form factor.
• Version flexibility: Supporting older OS versions without degrading experience too heavily allows broader adoption, and avoids alienating slower-adopting regions.
• Component isolation: Writing feature modules or SDKs that can plug into multiple host apps increases reuse and simplifies partner integrations.