MVC

Model-View-Controller is an architectural framework based on the decoupling of the 3 major categories:

Model - managing data domain (e.g. Data Model)
View - managing display domain (e.g. GUI)
Controller - listening to event and coordinate executions (e.g. Listen to Event to analyze Event to Run Data Model X function then pass the output to View X)

The coupling can be done in various way using any available behavioral patterns. Its diagram is often shown as follows:

When To Use (Problems)

When the system overall structure has many distinctive large categories, impossible to fuse together without sacrificing any of the design principles.
When the system overall structure has a lot of highly coupled functions, making testing impossible to execute.
When the system overall structure is planned for long term maintenance.

Examples (Solution)

There are many ways to implement MVC without specifically defining the behaviors between the 3 main categories. MVC can interacts with each others either actively or passively depending on which behavioral pattern used for their interactions.

Active Approach

Active model uses an observer behavioral pattern to drive the executions (event-driven). This is also known as reactive programming for MVC architecture patterns. Active approach's controller is mainly about event handling while most of the events are delegated to Model, interacting with Views to display the necessary output.

Passive Approach

Passive model uses naive pattern, template-method pattern, strategy pattern, etc. to sequentially execute the executions. This is the common and basic use of MVC approach. Passive approach's controller is mainly acts as the coordinator between the events, model, and views. There are heated debates where Model-View interactions should be forbidden for cleaner decoupling results, making it easier to maintain.

Expected Outcome (Consequences)

Decoupled major categories of responsibilities into 3 distinct types: data, coordination, and display.
Organized large system structures into a controllable, manageable, maintainable structures.
Permits testing for large system structure.
Requires developers to understand MVC architecture before contribution.

⮘ Back