Model-View-Intent (MVI) Software Architecture Pattern
(Redirected from Model-View-Intent (MVI) Architecture)
Jump to navigation
Jump to search
A Model-View-Intent (MVI) Software Architecture Pattern is a software architecture pattern that separates information representation from user interaction.
- Context:
- It can be followed by an MVI Platform.
- …
- Counter-Example(s):
- See: MVVM Pattern, Web Application Framework, Scala Play Platform.
References
2023
- chat
- Model-View-Intent (MVI) is an software architectural pattern used for designing and structuring the code of software applications, particularly those with user interfaces. It is an evolution of the Model-View-Presenter (MVP) and Model-View-ViewModel (MVVM) patterns, emphasizing unidirectional data flow and reactive programming principles. MVI is particularly popular in the context of modern web and mobile app development.
- The three main components of MVI are:
- Model: This component represents the state of the application. The model is an immutable data structure that contains all the relevant information needed to render the user interface. In MVI, the model is typically updated using reactive programming techniques, such as by observing a stream of actions or events.
- View: The view component is responsible for rendering the user interface and displaying the current state of the model. In MVI, the view is usually a lightweight component that merely observes the model and updates the UI accordingly. The view does not directly modify the model or interact with the intent.
- Intent: The intent component serves as the intermediary between the view and the model. It is responsible for handling user interactions, such as button clicks or text input, and translating them into actions or events. These actions or events are then processed and used to update the model. In MVI, intents are typically implemented using reactive programming techniques, such as observables or event streams.
- The MVI architecture enforces a clear separation of concerns between the different components of an application, making it easier to understand, maintain, and test. The unidirectional data flow ensures that the application state is always predictable and consistent, reducing the likelihood of bugs and simplifying debugging.
2021
- (Chauhan et al., 2021) ⇒ Kshitij Chauhan, Shivam Kumar, Divyashikha Sethia, and Mohammad Nadeem Alam. (2021). “Performance Analysis of Kotlin Coroutines on Android in a Model-View-Intent Architecture Pattern.” In: 2021 2nd International Conference for Emerging Technology (INCET), pp. 1-6 . IEEE.