[skydhash]

Controller is where your logic is. Your model is your state, and the view is presentation. Both are static. The controller is the dynamic aspect that update the view to match the state and update the state according to interaction or some other system events.

Splitting the logic from the state and presentation make the code very testable. You can either have the state as input and you test your presentation, or have the presentation as input (interaction and lifecycle events) and test your state (or its reflection in the presentation).

Also this decoupling makes everything more flexible. You can switch your presentation layer or alter the mechanism for state storage and retrieval (cache, sync) without touching your logic.

[mpweiher]

> Controller is where your logic is.

That's actually precisely the anti-pattern. Massive View Controller is an example of this.

The Model is where your logic is. Everything that is in any way semantically relevant.

Views handled display and editing (yes, also editing!). Controllers ... well ... I guess you might have a need for them.

[sunir]

The model is the source of truth. For almost all apps, it should always be valid. (For those apps that isn’t true such as massively distributed systems, it should present a projection of what can be considered valid to your locality and handle delta internally.)

There has to be a boundary that controls changes to the model. The confusion with MVC is where is the best place for this boundary. Well more than one place as it turns out because there are at least two models of reality trying to converge. The model itself and the view of the model (and the user’s mind).

The view’s job is to present a projection of the model and then collect change events to the model. Thus could be a UX or an API. Other events can also change the model like say sensor data.

The controller decides what view to show and retrieves model data to project and translates change events coming from the external world (views or events) into changes the model should interpret. This includes gatekeeping such as auth, and error handling.

That’s a lot for one class so it can get confusing very quickly. Why localize it in one place?

So viewtrollers come around where the controller is in the view class but in the onhandle methods. This also makes sense since each view has a mini controller to handle all the jiggling bits.

This works well when there are no orthogonal injections like auth or eventing. When those are added it makes sense ins viewtroller to extend the model with controller functionality to for eg control authorization or have a thin event receiver to fsm in the model.

This all works but three years later it’s hard to figure out when I read the code again. So I have learnt to treat the model as pure data as much as possible and the view as much about rendering as possible. Views can have little controllers for handling the jiggling. What the controller cares about is when a change to the system needs to happen.

Then I can put the system control fsm in one place. I can put all event handling in the same fsm to avoid race conditions.

The goal is to make it easier to reason about.

What I don’t want are multiple threads of fsms in conflict with each other.

[mpweiher]

> The model itself and the view of the model (and the user’s mind).

Trygve was very explicit about the model being a model of how the user thinks about the problem:

There should be a one-to-one correspondence between the model and its parts on the one hand, and the represented world as perceived by the owner of the model on the other hand.

https://web.archive.org/web/20090424042645/http://heim.ifi.u...

Second paragraph.

> There has to be a boundary that controls changes to the model.

Yes. It's called the API of the model. The model makes available API for all semantically valid operations. As I wrote elsewhere, I usually have a facade that acts as the top-level API for the model.

The views can call this API. So can other entities.

> The controller ... decides what view to show

possibly. But views can handle their own subview.

> The controller ... and retrieves model data to project

Nope. Not the job of the controller.

> The controller ... and translates change events coming from the external world (views or events) into changes the model should interpret.

Nope, it doesn't. The views typically do that as well. Controllers may be get involved if there is a complex sequence of steps that doesn't really naturally fit into a view.

> That’s a lot for one class so it can get confusing very quickly.

Yeah, if you put all sorts of stuff in the controller that doesn't belong there.

> Why localize it in one place?

Indeed. Don't incorrectly localize all these things in one place. MVC, for example, tells you not to do this.

> This all works but three years later it’s hard to figure out when I read the code again.

Yes. MVC is much better than that thing you came up with.

[sunir]

That’s a fair critique. Though the snark was unnecessary.

I took the time to reread the literature and review my actual code. My updated understanding.

Model controls and holds the state of the system. It ensures the data is always valid.

Controller controls the boundary between the system and the user.

View represent the model and capture user intent to change the model. They ask the model for data they need; however I disagree with the practice that views change data directly but instead prefer they send an intention to change to the app which does the work.

Auth was not considered in 1979 as far as I can tell. Authentication is part of the “controller” but in middleware usually because it’s part of the user input boundary, and generally better if done in one place early in the event lifecycle. Authorization is part of the model.

App logic is decomposed into workflows or use cases in the app layer. Events coming in through the controller are translated into what the system understands and then passes it onto the workflow to execute.

Thus these should take change intent from the view and then actually tell/ask the model what needs to change. This allows the app to catch errors from the model, recover if they can, or handle multi step flows. Results and errors are then sent back to the view (eg GUI dialog) or controller (eg api call) that initiated the workflow.

This makes it easier to put different views over the same app logic (mobile, web, api, agent) and also test workflows in isolation.

Modern views have their own controllers for mouse and keyboard. That’s fine. Don’t care. That’s effectively outside the system in the client experience (eg browser) anyway.

Where I have trouble is when I

- put a ton of app logic in the controller

- put a ton of model updates in the view

- have a single controller for the entire system instead of one per system boundary/interface of user events.

The (DDD?) style of app logic being encapsulated outside of the controller makes a lot more sense to me now that I see it.

[mpweiher]

Hmmm...the problems you recount are exactly the problems of putting (way too much) logic into the controller...and not enough logic into the model...which is exactly what MVC recommends you not do, and which is exactly what I criticized about your approach...and which is exactly the critique you seem unwilling to accept.

¯\_(ツ)_/¯

What gives?

Put all the logic in the model. If you want authentication, put that in an "authenticated model" that wraps your model. Don't put it in the controller.

> Controller controls the boundary between the system and the user.

Nope. That is Apple-MVC. Aka Massive-View-Controller. It is not MVC.

The model API is the boundary between the model and the rest of the system.

https://blog.metaobject.com/2015/04/model-widget-controller-...

[sunir]

The controller is meant to be handling things like keyboard events or http events. That’s the boundary to the user. The thinner the better.

I don’t know why you think this is a combative conversation where I need will to accept or reject anything. I lack understanding of how you would solve the same problem. Throwing chaffe is not communication. It creates a second problem beyond the one we are discussing.

How does the model handle authentication without having to become aware of boundary protocols? How the user authenticates is part of the input to the system. Eg http basic or oauth

I don’t know how you handle routing. Do you put that in the model as well?

[js8]

I always thought that business logic, expressed in the language of your domain, should be part of the model. The controller is just a translator from the language of keystrokes and mouseclicks into the domain language, and the view is just a translator from the domain language into pieces of text and widgets to display to the user.

[dsego]

In the server-side web world the controller should ideally only receive http actions and call services or fat models. It should have no business logic, only validation and parsing. In the frontend UI world the controller is bound to UI events and communicates those from the view to the model objects. (1).

(1) https://github.com/madhadron/mvc_for_the_web

[gf000]

Though it's probably easiest understood in a non-web world.

The web makes it quite a bit more involved with a separation of client- and server-side state - plus you have a given frontend "framework" in the shape of DOM, which people often leave out of the picture.

This latter necessities the 'escape hatches' in React and alia.