Currently, I&#39;m reading a lot about Software Engineering, Software Design, Design Patterns etc. Coming from a totally different background, that&#39;s all new fascinating stuff to me, so please bear with me in case I&#39;m not using the correct technical terminology to describe certain aspects ;-)

I ended up using [Reference Classes][1] (a way of OOP in R) most of the time because object orientation seems to be the right choice for a lot of the stuff that I&#39;m doing. 

Now, I was wondering if anyone has some good advice or some experience with respect to  implementing the **[MVC][2]** (Model View Controller; also known as **MVP**: Model View Presenter) pattern in R, preferably using Reference Classes.

I&#39;d also be very interested in info regarding other &quot;standard&quot; design patterns such as [observer][3], [blackboard][4] etc., but I don&#39;t want to make this too broad of a question. I guess the coolest thing would be to see some minimal example code, but any pointer, &quot;schema&quot;, diagram or any other idea will also be greatly appreciated!

For those interested in similar stuff, I can really recommend the following books:

 1. [The Pragmatic Programmer][5]
 2. [Design Patterns][6]

**UPDATE 2012-03-12**

I did eventually come up with a small example of my interpretation of MVC (which might not be totally correct ;-)).

## Package Dependencies ##

    require(&quot;digest&quot;)


## Class Definition Observer ##

    setRefClass(
        &quot;Observer&quot;,
        fields=list(
            .X=&quot;environment&quot;
        ),
        methods=list(
            notify=function(uid, ...) {
                message(paste(&quot;Notifying subscribers of model uid: &quot;, uid, sep=&quot;&quot;))
                temp &lt;- get(uid, .self$.X)
                if (length(temp$subscribers)) {
                    # Call method updateView() for each subscriber reference
                    sapply(temp$subscribers, function(x) {
                        x$updateView()        
                    })
                }    
                return(TRUE)
            }
        )
    )

## Class Definition Model ##

    setRefClass(
        &quot;Model&quot;,
        fields=list(
            .X=&quot;data.frame&quot;,
            state=&quot;character&quot;,
            uid=&quot;character&quot;,
            observer=&quot;Observer&quot;
        ),
        methods=list(
            initialize=function(...) {
                # Make sure all inputs are used (&#39;...&#39;)
                .self &lt;- callSuper(...)
                # Ensure uid
                .self$uid &lt;- digest(c(.self, Sys.time()))
                # Ensure hash key of initial state
                .self$state &lt;- digest(.self$.X)
                # Register uid in observer
                assign(.self$uid, list(state=.self$state), .self$observer$.X)
                .self
            },
            multiply=function(x, ...) {
                .self$.X &lt;- .X * x 
                # Handle state change
                statechangeDetect()
                return(TRUE)
            },
            publish=function(...) {
                message(paste(&quot;Publishing state change for model uid: &quot;, 
                    .self$uid, sep=&quot;&quot;))
                # Publish current state to observer
                if (!exists(.self$uid, .self$observer$.X)) {
                    assign(.self$uid, list(state=.self$state), .self$observer$.X)
                } else {
                    temp &lt;- get(.self$uid, envir=.self$observer$.X)
                    temp$state &lt;- .self$state
                    assign(.self$uid, temp, .self$observer$.X)    
                }
                # Make observer notify all subscribers
                .self$observer$notify(uid=.self$uid)
                return(TRUE)
            },
            statechangeDetect=function(...) {
                out &lt;- TRUE
                # Hash key of current state
                state &lt;- digest(.self$.X)
                if (length(.self$state)) {
                    out &lt;- .self$state != state
                    if (out) {
                    # Update state if it has changed
                        .self$state &lt;- state
                    }
                }    
                if (out) {
                    message(paste(&quot;State change detected for model uid: &quot;, 
                       .self$uid, sep=&quot;&quot;))
                    # Publish state change to observer
                    .self$publish()
                }    
                return(out)
            }
        )
    )

## Class Definition Controller and Views ##

    setRefClass(
        &quot;Controller&quot;,
        fields=list(
            model=&quot;Model&quot;,
            views=&quot;list&quot;
        ),
        methods=list(
            multiply=function(x, ...) {
                # Call respective method of model
                .self$model$multiply(x) 
            },
            subscribe=function(...) {
                uid     &lt;- .self$model$uid
                envir   &lt;- .self$model$observer$.X 
                temp &lt;- get(uid, envir)
                # Add itself to subscribers of underlying model
                temp$subscribers &lt;- c(temp$subscribers, .self)
                assign(uid, temp, envir)    
            },
            updateView=function(...) {
                # Call display method of each registered view
                sapply(.self$views, function(x) {
                    x$display(.self$model)    
                })
                return(TRUE)
            }
        )
    )
    setRefClass(
        &quot;View1&quot;,
        methods=list(
            display=function(model, x=1, y=2, ...) {
                plot(x=model$.X[,x], y=model$.X[,y])
            }
        )
    )
    setRefClass(
        &quot;View2&quot;,
        methods=list(
            display=function(model, ...) {
                print(model$.X)
            }
        )
    )

## Class Definition For Representing Dummy Data ##

    setRefClass(
        &quot;MyData&quot;,
        fields=list(
            .X=&quot;data.frame&quot;
        ),
        methods=list(
            modelMake=function(...){
                new(&quot;Model&quot;, .X=.self$.X)
            }
        )
    )

## Create Instances ##

    x &lt;- new(&quot;MyData&quot;, .X=data.frame(a=1:3, b=10:12))

Investigate model characteristics and observer state

    mod &lt;- x$modelMake()
    mod$.X

    &gt; mod$uid
    [1] &quot;fdf47649f4c25d99efe5d061b1655193&quot;
    # Field value automatically set when initializing object.
    # See &#39;initialize()&#39; method of class &#39;Model&#39;.

    &gt; mod$state
    [1] &quot;6d95a520d4e3416bac93fbae88dfe02f&quot;
    # Field value automatically set when initializing object.
    # See &#39;initialize()&#39; method of class &#39;Model&#39;.

    &gt; ls(mod$observer$.X)
    [1] &quot;fdf47649f4c25d99efe5d061b1655193&quot;

    &gt; get(mod$uid, mod$observer$.X)
    $state
    [1] &quot;6d95a520d4e3416bac93fbae88dfe02f&quot;

Note that the object&#39;s uid has automatically been registered in the observer upon initialization. That way, controllers/views can subscribe to notifications and we have a 1:n relationship.

Instantiate views and controller

    view1 &lt;- new(&quot;View1&quot;)
    view2 &lt;- new(&quot;View2&quot;)
    cont  &lt;- new(&quot;Controller&quot;, model=mod, views=list(view1, view2))

## Subscribe ##

Controller subscribes to notifications of underlying model

    cont$subscribe()

Note that the subscription has been logged in the observer

    get(mod$uid, mod$observer$.X)

## Display Registered Views ##

    &gt; cont$updateView()
      a  b
    1 1 10
    2 2 11
    3 3 12
    [1] TRUE

There&#39;s also a plot window that is opened.

## Modify Model ##

    &gt; cont$model$multiply(x=10)
    State change detected for model uid: fdf47649f4c25d99efe5d061b1655193
    Publishing state change for model uid: fdf47649f4c25d99efe5d061b1655193
    Notifying subscribers of model uid: fdf47649f4c25d99efe5d061b1655193
       a   b
    1 10 100
    2 20 110
    3 30 120
    [1] TRUE

Note that both registered views are automatically updated as the underlying model published its state change to the observer, which in turn notified all subscribers (i.e., the controller).

## Open Questions ##

Here&#39;s what I feel like I&#39;m not fully understanding yet:

 1. Is this a somewhat correct implementation of the MVC pattern? If not, what did I do wrong?
 2. Should &quot;processing&quot; methods (e.g. aggregate data, take subsets etc.) for the model &quot;belong&quot; to the model or the controller class . So far, I always defined everything a specific object can &quot;do&quot; as methods of this very object. 
 3. Should the controller be sort of a &quot;proxy&quot; controlling every interaction between model and views (sort of &quot;both ways&quot;), or is it only responsible for propagating user input to the model (sort of &quot;one way&quot;?

  [1]: http://stat.ethz.ch/R-manual/R-devel/library/methods/html/refClass.html
  [2]: http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller
  [3]: http://en.wikipedia.org/wiki/Observer_pattern
  [4]: http://en.wikipedia.org/wiki/Blackboard_system
  [5]: http://www.amazon.com/The-Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1331597257&amp;sr=1-1
  [6]: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

All Reference Class Solutions on Gang of Coders

Total of 1 Reference Class Solutions

Implementing standard software design patterns (focus on MVC) in R