Monday, July 7, 2008

MVC: How to write controllers

I've been working on many projects (web and desktop applications), and I must say that the way MVC is implemented varies a lot. That's probably a good thing, since every project is different. I believe, however, that there are some common patterns that could improve most of the MVC applications.1. Keep it simple

Don't create additional tiers unless they are needed. Every class should clearly belong to either Controller, Model or a View.

2. Thin controller, fat model

This is probably the most useful lesson I learnt from the Rails world. I'm not going to elaborate on that here, as it was covered in many other places. Just move all your logic to models. It's that simple.

3. RESTful design

If you work on a web application, and still don't know what REST is, then go and read about it. It's easy and it will simplify your design a lot. Basically, it makes you think about your app as a set of resources. Every action in your controllers does one of the following with your resources: new, create, edit, update, show, destroy, index(list). At first, it can feel as a limitation, but it is the kind of limitation that actually helps you.

Many people argue that not everything can be RESTified. I agree that there are places where REST is not needed, however it's always a good exercise to find a RESTful solution.

4. Communication between controllers and models

As always, when you delegate some work further, you need to control the result somehow. The same happens when you move all the logic from controllers to models.

There are three ways (that I'm aware of) of implementing the communication between a controller and a model.

4a. Return codes

You use return codes when your model methods return not the data, but the result of an operation.

An example here is ActiveRecord::Base.save method which returns true when the save was successful, false otherwise.

This is slightly better than a), because the return code knowledge is hidden in method calls, but we still see the problem of many "if" statements.4c. Don't ask, tell. Use custom exceptions

That's my favorite, because it eliminates all the "if"s from my controller code. I know it's just a syntactical change, but I prefer to see something like this in my controller, rather than the example above:

Here we use custom exceptions to define a "protocol" for the communication between a model and a controller. Obviously we need to define the exceptions somewhere. I like to add them at the top of the associated model class:

I think this is where Rails could be improved (or my lack of knowledge of the framework) because it doesn't separate Application Logic (AL) from Business Logic (BL).

In a traditional n-tier web architecture, the AL is triggered by URLs and instantiate the appropriate BL object, which, as its name implies, operates the real logic of your application. That way you can share the BL among all the representations of the result. (REST,SOAP, anything)

I implemented this in PHP, so I don't see how it couldn't be done in RoR or any other upper-class framework. What do you think ?

I sort of agree with the notion of skinny controllers and fat models -- at least in terms of tiers. However, Rails encourages a fairly narrow view of what constitutes a model. In a typical rails app, developers tend to think of models mainly as database backed data objects, and this often leads to shoving all the business logic into these data objects, rather than finding a more appropriate place for it by breaking things out into other classes (i.e. classes that are part of the model layer, but don't represent ActiveRecord models themselves). The default setup works great for CRUD based / RESTful apps, but once an app becomes more complex, the business logic should probably be extracted into proper, more granular domain objects, some of which may represent ActiveRecord models, while others may not.

I agree that version 4c is very clean and readable, but it troubles me in that it uses exceptions for things that are not (in my opinion, at least--perhaps some would disagree) really exceptions.

I understand exceptions to be failures, errors, cases that your code fails to account for, but needs to recover from. A credit card being declined is a very normal condition which you need to handle, not really an exception.

If we don't honor this distinction, your more readable code might be less readable 6 months from now, because glancing down the page you see exception handling and (unless you look at it closely and think about what it's doing) assume it's really there for handling exceptions.

As soon as you set up your online business, you would definitely come across the challenge of surviving in a quickly growing competitive environment. Moreover, the ever-changing market trends would also pose challenges to you and at such a situation, efficient ecommerce solution may provide you the best business advantage that you can ever dream of. Come in touch with http://www.infyecommercesolution.com and avail of the best ecommerce solutions.