MVC is actually quite simple. What complicates discussions of it with respect to old Smalltalk systems is that it was tied up into the UI paradigm of the time. You have three actors in typical MVC:

• the model: the actual object of interest (I would say "business objects" but that's too limiting, of course). These have no idea how they're being watched or controlled, just that they may be. They notify interested Views of potentially interesting changes to themselves.
• the view: what gets notified when the model says that it's changed
• the controller: this is what (in Smalltalk MVC systems) translates user input events (mouse/keyboard, etc.) into actions on the model.

Many newer UI systems based on windowing systems merge the view and controller into a single widget. So the C in MVC is mostly not useful. This is why (for instance) the Observer pattern in Design Patterns only has two participants (once you get past the C++ inheritance crap). The important idea is this: the model notifies views when it changes. The views then can update themselves as needed. The easiest implementation of this is to have each model keep a list of views. Upon a change, the model sends a message to each of the views saying that it's changed. Some systems include an indication of what has changed.

package Model;   # mix in to model classes that are
                 # implemented as blessed hashes

# This is called by a View
sub addDependent
{
    my $self = shift;
    my $dependent = shift;
    my $dependents = (self->{dependents} ||= []);
    push @$dependents, $dependent;
}

# This is called by a View
sub removeDependent
{
    my $self = shift;
    my $dependent = shift;
    my $dependents = $self->{dependents} || return;
    @$dependents = grep { $_ != $dependent } @$dependents;
}

# This is called by the Model
# you can pass additional data as needed
sub _changed
{
    my $self = shift;
    my $dependents = $self->{dependents} || return;
    foreach my $dependent ( @$dependents )
    {
        $dependent->update($self, @_);
    }
}

package View;   # mix in to observer classes of any kind

sub update  # stub: do nothing
{
    my ($self, $model, @aspectData) = @_;
}
[download]

Then this gets used like this (in a Model class):

package MyModel;
@MyModel::ISA = qw(SomethingElse Model);

sub changeSomething
{
    my $self = shift;
    my $value = shift;
    $self->{something} = $value;
    $self->_changed('something', $value);
}
package MyView;

sub update
{
    my ($self, $model, $aspect, $otherStuff) = @_;
    # hey! $model has changed its $aspect!
}

package main;

my $view = bless {}, 'MyView';
my $model = bless {}, 'MyModel';

$model->addDependent($view);

# now the following
# calls $view->update($model, 'something', 123);
$model->changeSomething(123);
[download]

The passing of the new value is an optimzation, and is not strictly necessary.

update: added more sample code

---

---

Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!

Titles consisting of a single word are discouraged, and in most cases are disallowed outright.

Read Where should I post X? if you're not absolutely sure you're posting in the right place.

Please read these before you post! —

• How do I compose an effective node title?
• How do I post a question effectively?
• Markup in the Monastery

Posts may use any of the Perl Monks Approved HTML tags:

a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, details, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, summary, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr

You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)

	For:		Use:
	&		&
	<		&lt;
	>		&gt;
	[		&#91;
	]		&#93;

Link using PerlMonks shortcuts! What shortcuts can I use for linking?

See Writeup Formatting Tips and other pages linked from there for more info.