Mobile App Development Architecture and Quality Syllabus

Architecture and Quality syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Architecture and Quality in Mobile App Development, not a summary of it.

1. 1

   Architectural Patterns

   4 topics

   • MVC, MVP, and MVVM
   • MVI and Unidirectional Data Flow
   • Clean Architecture
   • Dependency Injection
2. 2

   Testing

   4 topics

   • Unit Testing
   • UI and Integration Testing
   • Widget and Component Testing
   • Test-Driven Development
3. 3

   Performance Optimization

   4 topics

   • Profiling and Memory Management
   • Rendering and Frame Rates
   • App Startup and Battery Usage
   • Network and Image Optimization
4. 4

   Security Best Practices

   4 topics

   • Secure Data Storage
   • Network Security and SSL Pinning
   • Code Obfuscation and Tampering
   • OWASP Mobile Top 10

Architecture and Quality flashcards for Mobile App Development

20 of 57 cards from the Architecture and Quality deck — real questions with worked answers.

1. In the MVC pattern, what are the three components and their primary responsibilities?

   Model (holds data and business logic), View (renders the UI), and Controller (handles user input, updates the Model and selects the View). The Controller mediates between View and Model.

2. How does MVP differ from MVC in terms of the View-logic relationship?

   In MVP the Presenter fully handles presentation logic and the View is passive, communicating only through an interface. Unlike MVC, the View never talks directly to the Model; all interaction goes through the Presenter (typically a 1:1 View-Presenter relationship).

3. In MVVM, what binds the View to the ViewModel and what does the ViewModel expose?

   Data binding (often two-way) connects them. The ViewModel exposes observable state/streams and commands; it has no reference to the View, so the View passively reflects ViewModel state.

4. Compare the coupling of the presentation layer to the View across MVC, MVP, and MVVM.

   MVC Controller may hold a View reference (moderate coupling); MVP Presenter references the View via an interface (testable, decoupled from framework); MVVM ViewModel has no View reference at all (loosest coupling, driven by data binding).

5. Which of MVC/MVP/MVVM is generally easiest to unit test and why?

   MVP and MVVM are both highly testable. MVVM is often favored because the ViewModel has no View reference and exposes plain observable state, so it can be tested with no UI or mocking of the View.

6. What are the four components of the MVI (Model-View-Intent) pattern?

   Intent (user actions/events), Model (a single immutable state), View (renders the state), and a reducer/processor that maps Intent + current State to a new State. State flows in one direction.

7. Define Unidirectional Data Flow (UDF).

   An architecture where state flows in a single direction: events/intents go up to a state holder, which produces a new immutable state that flows down to the UI. There is one source of truth and no two-way binding loops.

8. In MVI, why is the state typically immutable and singular?

   A single immutable state object guarantees a predictable, reproducible UI (state is a pure function of past intents), eliminates inconsistent partial updates, and makes debugging, time-travel and testing straightforward.

9. What is a reducer in a unidirectional data flow architecture?

   A pure function with the signature $newState = reduce(currentState, action)$ that takes the current state and an action/intent and returns the next state without side effects.

10. State the Dependency Rule of Clean Architecture.

    Source-code dependencies must point only inward, toward higher-level policies. Inner layers (entities, use cases) know nothing about outer layers (frameworks, UI, DB); dependencies always cross boundaries pointing inward.

11. List the concentric layers of Clean Architecture from innermost to outermost.

    Entities (enterprise business rules) -> Use Cases/Interactors (application business rules) -> Interface Adapters (presenters, controllers, gateways) -> Frameworks & Drivers (UI, DB, web, devices).

12. How does Clean Architecture keep inner layers independent of outer frameworks?

    Through dependency inversion: inner layers define interfaces (ports) that outer layers implement. At runtime dependencies are injected inward, but at compile time the arrows point inward, so business logic never depends on frameworks.

13. What is a Use Case (Interactor) in Clean Architecture?

    A class encapsulating a single application-specific business rule/action (e.g., 'Login user'). It orchestrates entities and calls outward through repository interfaces, remaining independent of UI and data sources.

14. Define Dependency Injection.

    A design technique in which an object receives (is 'injected' with) its dependencies from an external source rather than creating them itself, decoupling construction from use and enabling substitution/testing.

15. Name the three common forms of Dependency Injection.

    Constructor injection (dependencies passed via the constructor), setter/property injection (via a setter method or property), and method/interface injection (passed as a method parameter).

16. How does the Dependency Inversion Principle relate to Dependency Injection?

    DIP is the principle: high-level modules depend on abstractions, not concretions. DI is a technique that realizes DIP by supplying the concrete implementation of an abstraction from outside the dependent class.

17. What is an IoC (Inversion of Control) container?

    A framework that manages object creation, lifetime/scope, and dependency resolution automatically, wiring dependencies into objects so developers do not manually construct the object graph.

18. What is a unit test?

    An automated test that verifies the smallest testable piece of code (a single unit/function/class) in isolation from its dependencies, which are replaced by test doubles, to confirm it behaves correctly.

19. Explain the AAA pattern used to structure a unit test.

    Arrange (set up objects, inputs and mocks), Act (invoke the method under test), Assert (verify the outcome matches the expected result). It keeps tests readable and focused.

20. Distinguish a mock, a stub, and a fake as test doubles.

    Stub returns canned responses to calls; Mock is pre-programmed with expectations and verifies interactions (behavior verification); Fake is a lightweight working implementation (e.g., in-memory DB) unsuitable for production.

See more Architecture and Quality flashcards →

Planning Architecture and Quality for Mobile App Development

Architecture and Quality (Mobile App Development) FAQ