Model-View-Controller (MVC) Design Pattern Quiz

What manages one instance of the app's UI, including one or more windows displayed from that scene?

Which object is responsible for managing the life cycle of one instance of the app's user interface?

What type of objects store an app's content and are specific to each app?

Which objects manage the presentation of an app's content on screen?

If an app supports scenes, what delivers separate life-cycle events for each scene?

What is responsible for handling the initial routing of incoming user events in an iOS app?

Which object is considered as the root object of an iOS app and manages shared behaviors?

What does UIWindow do in an iOS app with respect to view controllers?

Which object is responsible for creating additional windows in an iOS app as needed?

What is the main role of the UIWindowSceneDelegate in an iOS app?

What does the UIApplicationMain function do during the app startup process?

What does the UIWindowScene delegate do in iOS 13 and later?

Which method is called by UIApplicationMain during the app launch process?

What does the UISceneSession represent in iOS app development?

Which object serves as the shared application instance in an iOS app?

What delivers all life-cycle events to the UIApplicationDelegate object in iOS 12 and earlier, and in apps that do not support scenes?

Which file contains metadata about the app in iOS and is used by the system to interact with the app?

What must every app declare to specify the hardware capabilities or features that it requires to run?

What does Xcode automatically create based on the project's configuration and settings?

When an iOS app is launched, what does the system display as a temporary screen until the app can show its user interface?

What is the role of controller objects in an application?

How do view objects in a Model-View-Controller (MVC) architecture learn about changes in model data?

What is one of the tasks performed by controller objects in an application?

In Model-View-Presenter (MVP), what does the presentation layer decide?

How does Model View Presenter (MVP) pattern differ from Model-View-Controller (MVC) pattern?

Which role is responsible for encapsulating the data specific to an application and defining the logic and computation that manipulate and process that data?

In the MVC design pattern, the Controller acts as an intermediate between which two components?

Which part of an application is more easily extensible when it is designed using the MVC pattern?

In the context of MVC, which component would be responsible for updating the screen after a user action like sending a message?

What is the main function of a Model object in an application following the MVC pattern?

Which component in the MVC/MVP architecture handles user interaction like click listeners?

In MVC/MVP architecture, which layer acts as the middle layer between the View and Model layers?

Which component of the MVC/MVP architecture is responsible for describing the main logic of the application and deciding from where the data should be fetched?

What makes Models and Views reusable in MVC/MVP architecture?

Which component in MVC/MVP is NOT much dependent on the View and does not contain UI components?

What role does the View play in the MVC/MVP architecture?

Which layer of the MVC/MVP architecture is responsible for fetching data from the model and presenting it in a user-friendly format?

Why is an application easier to maintain and extend over time when following MVC/MVP architecture?