Models and Controllers: Who are you calling fat?

As confirmed during the latest article about MVC, one of the greatests discussions around the subject is: Where’s the fat going?

The discussion goes between the two layers, Model and Controller, and has caused a lot of buzz since the MVC boom. So lets take a closer look…

Remembering the principles
As the pattern describes, the Model is responsible for the data that will be feeded to the user through the view layer. The Controller gets the data from the model and forward to the view in the desired manner.

NOTE: I will use PHP to illustrate the cases. The examples are very simple to be easy to comprehend so you can apply to your language of choice.

The Fat Model
The Fat Model is what the “Fat Model, Skinny Controller” principle (pointed greatly by Alvaro) defends. Following strictly this proposed vision of MVC, the Fat Model is which fits best since it keeps the data-relative code (business logic) at the data-relative layer (Model) where the Controller exchanges data between the View and the processed data. It keeps the Controller “Skinny” (uhh.. sexy!) and ready for summer!

So to get a very dummy example:

UserController (Skinny one)

public function viewProfile($user) {
    $user = User::findByUsername($user); // example ORM model
    // ... here goes some code
    $user->raiseProfileView();
    $this->render('user/profile.tpl'); // example view rendering
} // end :: function :: viewProfile

UserModel (who’s got the pizza?)

public function raiseProfileViews() {
    $this->views++;
    $this->save();
} // end :: function :: raiseProfileViews

At this point of view we can even purpose that non-database data may be manipulated by the Model layer if its a heavy load or business logic.

NOTE: The Fat Model principle aids to stay DRY.

The Fat Controller
It’s another very commom practice in the code wilderness where the controller handle the business logic and some heavy stuff leaving the models strictly to the DBAL/ORM paper. Even not following exactly the pattern’s principle it’s is another point of view since the Controller actually “controls” everything.

UserController (Chubby one)

private function raiseProfileView($user) {
    $user = User::findByUsername($user); // example ORM model
    $user->views++;
    $user->save();
} // end :: function :: raiseProfileView
 
public function viewProfile($user) {
    $user = User::findByUsername($user); // example ORM model
    // ... here goes some code
    $this->raiseProfileView($user);
    // ... more code
    $this->render('user/profile.tpl'); // example view rendering
} // end :: function :: viewProfile

…and this way we don’t bother the Model so she can keep watching to soup operas and painting her toes.

To be, or not to be strict?
Hail the evangelists! This is wood for fire absolutely. It comes from coder to coder, and that I leave that to you.

And what’s your style?