I have recently learned about the MVC design pattern. I'm learning from the Head First Design Pattern book.

According to this book (if I understand correctly):

The Model is most of the application logic and data.

The View is basically the GUI that represents the Model visually to the user.

The Controller is responsible to 'mediate', and act as a 'middleman' between the View and the Model. The View reports to the Controller that the user made an action, and the Controller translates it to method calls on the Model. The following figure shows what is described above: enter image description here

However, a lot of places on the web contradict what I understand from that book. They claim that generally the user interacts with the Controller, not the View. The following figure illustrates the contradiction

enter image description here

Which one is true or more common? Does the user interact with the Controller directly, or with the View directly? Are both approaches acceptable? Which is more common?


3 Answers 3


The user interacts with the View, but the View must communicate the actions to the Controller. The Controller may update the Model, but it isn't required with every/any change.

The description I am providing is based on my personal experience with the .NET implementation of MVC. Your implementation can be different.

The Controller is where actions are processed, basically a business layer. A simple controller will do nothing more than get the data from the Model to feed to the View. A complicated Controller will perform all sorts of actions, up to security management, authentication, authorization, registration, and possibly many other things.

The View should only be responsible for displaying the information in a fashion that the user can understand. There can be some cross over here with both the Controller and the Model as things like Single Page Applications (SPAs) will have data validation feedback for the user. Any other cross overs are heavily frowned upon.

The Model deals with data. This includes validation of data (where applicable). Data storage and retrieval is also handled in this layer.


There seems to be some confusion surrounding who does what when. I included two different overviews of the MVC architectures because they are similar, but not the same. There is room for either interpretation. Possibly, many more. The descriptions above are my interpretation of MVC from multiple sources, including my own experience building applications using this methodology. Hopefully, this update will help to clear up some of this confusion.

MVC is an attempt to build a Separation of Concerns design pattern for software development. It has primarily been implemented in web based applications (to my knowledge).

The View handles all of the user interaction. If your user clicks on a button, the View determines if the click is a user interface interaction or something that is beyond its concern (a Controller interaction). If the button does something like copy values from one field to another, your implementation will determine if that is a View concern or a Controller concern. You will most likely only have this blurring of concerns when dealing with a Single Page Application (SPA).

The Controller is where your actions are processed. The View has communicated the user decided to change values for some fields. The Controller may perform validation on that data or it may be handled by the Model. Again this is implementation dependent. If the Controller has security features, it may determine that the user doesn't have sufficient privileges to perform the action. It would reject the changes and update the View accordingly. The Controller also determines what data to retrieve from the Model, how to package it, and update the View with that data.

The Model determines how and where to store data. It may also perform validation of that data before storing it (it should do this because people will bypass the View on occasion).

Wikipedia has an article on MVC.

  • A model notifies its associated view/views and controllers when there has been a change in its state. This notification allows views to update their presentation, and the controllers to change the available set of commands. In some cases an MVC implementation might instead be "passive," so that other components must poll the model for updates rather than being notified.
  • A view is told by the controller all the information it needs for generating an output representation to the user. It can also provide generic mechanisms to inform the controller of user input.
  • A controller can send commands to the model to update the model's state (e.g., editing a document). It can also send commands to its associated view to change the view's presentation of the model (e.g., by scrolling through a document).

From Microsoft's Overview of MVC.

  • Models. Model objects are the parts of the application that implement the logic for the application's data domain. Often, model objects retrieve and store model state in a database. For example, a Product object might retrieve information from a database, operate on it, and then write updated information back to a Products table in a SQL Server database.

    In small applications, the model is often a conceptual separation instead of a physical one. For example, if the application only reads a dataset and sends it to the view, the application does not have a physical model layer and associated classes. In that case, the dataset takes on the role of a model object.

  • Views. Views are the components that display the application's user interface (UI). Typically, this UI is created from the model data. An example would be an edit view of a Products table that displays text boxes, drop-down lists, and check boxes based on the current state of a Product object.

  • Controllers. Controllers are the components that handle user interaction, work with the model, and ultimately select a view to render that displays UI. In an MVC application, the view only displays information; the controller handles and responds to user input and interaction. For example, the controller handles query-string values, and passes these values to the model, which in turn might use these values to query the database.

  • What if you don't have GUI for all the actions? What if you have only API implemented for some specific parts? Does that mean user sometimes interacts with the View and sometimes with the Controller directly?
    – Mahdi
    Commented Mar 29, 2014 at 9:29
  • 2
    From my perspective, no. The API takes the place of the view. Commented Mar 29, 2014 at 9:39
  • but the API could be a simple url-routes, placed in the Controller. I mean no View at all ...
    – Mahdi
    Commented Mar 29, 2014 at 10:58
  • 1
    @AdamZuckerman Thanks for answering. In the next comment I'll describe how I think a common MVC implementation works, please confirm if it's correct or not. Thanks
    – Aviv Cohn
    Commented Mar 29, 2014 at 13:48
  • 3
    @Mahdi An API, by definition, is there as a programming interface, not a user interface. Programs interact with the API, users interact with the View.
    – Eric King
    Commented Mar 29, 2014 at 21:27

The user interacts with the Controller. From the technical point-of-view you're not interacting with the View, you're just using it to interact with the Controller.

On the surface it seems that the user is interacting with the GUI -- also to a non-programmer this makes more sense, however by clicking on a button you're basically talking to the Controller not the View.

Also not all the applications -- even MVC web-applications, does have a GUI. You might interact with the Controller via an API -- just simple url-routes for example, placed in the Controller itself.

The Controller should be the place that Receives and Handles the user requests. So if you're somehow accessing the Model directly from View -- doesn't matter how, then it's not MVC anymore.

  • 3
    +1 This is correct. Things like menus and toolbars are part of the GUI but not part of the view, and go straight to the controller. Keystrokes likewise.
    – david.pfx
    Commented Mar 29, 2014 at 13:45
  • 1
    The reason views exist as an abstraction is so we can substitute them easily when necessary. A controller for an app on various platforms can be the same, but the views have to recognize user gestures differently and translate them into controller operations. I disagree, therefore, that users interact directly with controllers. Commented Mar 29, 2014 at 18:06
  • 1
    @Mahdi I would say that in that case, there's no user interaction at all, it's the view communicating with the controller programmatically. The only interactions that are initiated by the user are via the view.
    – Eric King
    Commented Mar 29, 2014 at 21:25
  • 1
    @david.pfx Keystrokes can't go directly from a browser window to a Controller. Commented Mar 29, 2014 at 23:41
  • 2
    @Izkata "The View is the part of the code that requests are sent to" -- Sorry but this is the worst thing I heard here. How is that even possible? Can you back it up by providing a reference in an article or book?
    – Mahdi
    Commented Mar 30, 2014 at 8:44

Let's use a concrete example of why users interact directly with views and not controllers.

In the music app on the iPhone, a high level feature is to play a playlist. "Play a playlist" is a function of a controller to the app.

There is more than one way to activate that function. I can click on the playlist inside of the app, or I can ask Siri (voice interface) to perform the same function. Those are two different gestures that are recognized by the various views.

The feedback in each view is also different. Siri will tell you that it is playing the music you requested. The music app will show you a visual feedback that it is playing the playlist.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.