All
Historical
Significant
Java
JavaScript
Microsoft
PHP
Python
Ruby
Smalltalk
1980 1990 2000 2010 Classic MVC Application Model MVP MVVM Miscellaneous Server MVC TMVE 1979 T. Reenskaug MVC 1979 T. Reenskaug PAC 1987 J. Coutaz MVC K&P 1988 Krasner & Pope Application Model 1993 VisualWorks Observer Pattern 1994 GoF Data Binding 1995 unknown MVP 1996 Taligent Model 2 1998 J2EE MVA 2001? Cocoa? Presentation Model 2004 M. Fowler MVVM 2005 Microsoft MVW 2012 unknown Interface Builder 1986 HyperCard 1987 Action! 1988 NeXTstep 1988 WorldWideWeb 1990 Dolphin 1996 MS-Access 1995 SWING 1998 Struts 2000 Rails 2004 Silverlight 2007 Sproutcore 2007 Sproutcore 2007 Ember.js 2011 APS.NET MVC 2008 Angular.js 2009 Backbone 2010 Knockout.js 2010

1979 TMVE

Trygve Reenskaug writes a memo, A note on Dynabook requirements, that describes his design for a project management task. A couple of months later in another memo the Thing-Model-View-Editor metaphor is explored.

Pattern Elements

  • Thing: Something that is of interest to the user. It could be concrete, like a house or an integrated circuit. It could be abstract, like a new idea or opinions about a paper. It could be a whole, like a computer, or a part, like a circuit element.
  • Model: A Model is an active representation of an abstraction in the form of data in a computing system.
  • View: To any given Model there is attached one or more Views, each View being capable of showing one or more pictorial representations of the Model on the screen and on hardcopy. A View is also able to perform such operations upon the Model that is reasonabely associated with that View.
  • Editor: An Editor is an interface between a user and one or more views. It provides the user with a suitable command system, for example in the form of menus that may change dynamically according to the current context. It provides the Views with the necessary coordination and command messages.

1979 MVC

Trygve Reenskaug revamps TMVE into MVC in Models-Views-Controllers.

Pattern Elements

  • Model: Models represent knowledge. A model could be a single object (rather uninteresting), or it could be some structure of objects.
  • View: A view is a (visual) representation of its model. It would ordinarily highlight certain attributes of the model and suppress others. It is thus acting as a presentation filter.
  • Controller: A controller is the link between a user and the system.

1986 Interface Builder

1987 PAC

Developed independently from MVC by Joëlle Coutaz in: PAC, an Object Oriented Model for Dialog Design.

In an email response J. Coutaz said that:

when she formulated PAC, that she was unaware of MVC, and that she chose the word "control" independently. She later discovered MVC and was delighted to see the similarities, but also noted that her (independently coined) term "control" was similar to the term "controller" used with a very different meaning.
All this was reported by Kyle Brown in Whats a Controller Anyway

Pattern Elements

  • Presentation: the Presentation defines the concrete syntax of the application, i.e. the input and output behavior of the application as perceived by the user. The Presentation of an application is a set of entities, called interactive objects, specialized in man-machine communication.
  • Abstraction: the Abstraction part corresponds to the semantics of the application. It implements the functions that the application is able to perform. These functions are supposed to result from a thorough task analysis.
  • Control: the Control part maintains the mapping and the consistency between the abstract entities (involved in the interaction and implemented in the Abstract part) and their presentation to the user. It embodies the boundary between semantics and syntax. It is intended to hold the context of the overall interaction between the user and the application.

1987 HyperCard

1988 MVC K&P

Glenn E. Krasner and Stephen T. Pope published a variation of MVC in A Cookbook for Using the Model-View-Controller User Interface Paradigm in Smalltalk-80.

Pattern Elements

  • Model: The model of an application is the domain-specific software simulation or implementation of the application's central structure.
  • View: Views deal with everything graphical: they request data from their model, and display the data.
  • Controller: Controllers contain the interface between their associated models and views and the input devices (e.g., keyboard, pointing device, time).

1988 Action!

An interface builder, written by Denison Bollay, that allows editing of the application at run time.

A highly recommended read about the history behind this tool and how it relates to other technologies is found here: Interface Builder's Alternative Lisp timeline

To me, Action! is one the “holy grail” items from the history of user interfaces, if not IT more generally.
Paul Hammant

1988 NeXTstep

NextSTEP is an object-oriented, multitasking operating system which was developed by NeXT Computer, Inc.

I started working with NeXTSTEP in '92, which was strongly modelled MVC; and delegation over inheritance for that matter.
Erik Dörnenburg

NeXTstep was later modified to separate the underlying operating system from the higher-level object libraries. The result was the OpenStep API, a predecesor of Mac OS X and the Cocoa API.

1990 WorldWideWeb

Later renamed to Nexus to avoid confusion between the software and the World Wide Web; is the first web browser and editor.

Tim Berners Lee once commented that his pioneering World-Wide-Web application was only feasible at the time because of NeXTstep.

The first web site was published in 1990 and it is still online: The World Wide Web project

1993 Application Model

Used in VisualWorks, a dialect of Smalltalk sold by Cincom as part of Cincom Smalltalk.

Smalltalk an Introduction to Application Development Using VisualWorks (1995) is a book that provides a comprehensive description of the VisualWorks 2.0 development environment and its implementation of MVC.

Key features:

  • Properties are turned into objects that are observable. Say a string property is wrapped with an object that has getters and setters. The wrapper is observable and the mapping between widgets and model is a little easier.

As Smalltalk developed in the 80's and 90's this led to some significant variations on the classic MVC model. Indeed one could almost say that MVC disappeared, if you consider the view/controller separation to be an essential part of MVC - which the name does imply.

Pattern Elements

  • Domain Model: Some object or objects that represent your domain.
  • Application Model: Handle user interaction and re-direct messages to the domain model if necessary. Observes the domain model and provides property objects. Deals with view logic and view state.
  • View: Each view should display a particular visual representation of some aspect of the model.
  • Controller: Manipulates the model and the changes should be reflected in the view.

1994 Observer Pattern

Although the technique had been in use since the early days of MVC, it was first described in the book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides. The authors are often referred to as the Gang of Four (GoF).

1995 Data Binding

1995 MS-Access

In the 90's Microsoft loved "data binding" where UI controls were coupled to rows in database tables. To some this is the antithesis of MVC, and might be the primary reason Microsoft was late to the MVC party.

The 1995 Microsoft Access had a perfectly functional data binding capability. MS Access bound a record in a database table to the form showing it. Forms had next/previous ("<" and ">") controls. When those were interacted with the form would transition to the intended row in the table, with the data-bound fields in the form updating automatically. If the user had changed some fields in the form, before hitting next, they would be saved automatically too when next/prev was pressed. It was possible to veto the advancing of the form, but the data-bound nature of the form and the fields from a database attempted to be dominant. In the context of MVC, there was no intermediate model. The view (form) was wired directly to the database.

ActiveX had a data-binding technology called ActiveX Data Objects (ADO). Microsoft released ADO in October 1996.

MicroSoft launched .Net for public consupmtion in 2000. One facet of that was Active Data Objects (ADO.NET). Obviously that was taking ADO into the new .NET era. It very much continued the data-bound style, and UI technologies for .NET were also wired to it.

In 2003, Erik Dörnenburg wrote a technology called .NET Entity Objects Framework (NEO). He had worked with NeXTSTEP in '92, which was strongly modelled on MVC, and Enterprise Objects Framework (EOF) specifically, and wanted to bring some of that to .NET. He was also an Agile enthusiast, and wanted to have as much testable code as possible. He made Neo to help separate ADO.NET a little and allow some that testable, separative goodness. Neo as a persistence technology worked very well with WinForms.NET, at the time, It also had some other strong non-functional features but they are not important to this description. Erik later presented on this at a conference "Data programming beyond ADO.NET" in 2004 (see his old presentations page - scroll to the bottom), and some time after Microsoft bundled non data-binding technologies with .NET, but it could have been a coincidence. That started their patronage of the MVP sub-family of patterns.

MS being a patron of data-binding for many years might be one part of why they were so late to a proper implementation of MVC. Late being ASP.Net MVC in 2008.

1996 MVP

First described by Mike Potel from Taligent Inc. in MVP: Model-View-Presenter, The Taligent Programming Model for C++ and Java

Pattern Elements

  • Model: Deals with data management. How do I change my data? How do I specify my data? What is my data?
  • View: Deals with user interface. How do I display my data? How do events map into changes in my data? It hands off events to the presenter, similar to what Application Model does. But, it observes the Model, so the View updates itself.
  • Presenter: The View-Controller of a basic MVC is refered as Presentation. This represents the function of the classic Smalltalk controller, but elevated to an application level and taking into account the intermediate selection, command, and interactor concepts. Its role is to interpret the events and gestures initiated by the user and provide business logic. The classic Controller faded into the View.

1996 Dolphin

Dolphin, the Object Arts Ltd implementation of Smalltalk, used MVP as its UI model. The design is derived from the Taligent C++ system.

The research and reasonings behind that decision are found in a paper by Andy Bower and Blair McGlashan called: Twisting the Triad, published in 2000. In their research about MVC, they used VisualWorks 2.5 which actually refers to Application Model and in their paper both terms are used interchangeably.

A detailed timeline about Dolphin can be fount at: Ian's Dolphin Smalltalk Pages

1998 Model 2

A design pattern used in Java Web applications described in JavaServer Pages - Specification 0.92 (October 1998, if not before). A year later after release it was formally associated with MVC. The diagrams in the that link show a MVC-like design, but without calling it that explicitly.

When JavaServer Pages (JSP) as a template technology for Java was created, the initial reaction was “just like ASP”. It was also the case that the JSP page was the end point, with URLs ending in .jsp very common. Other technologies (Perl and alike) already had more abstracted ways of composing web applications, and something was needed for the Java servlet ecosystem.

"Model 2" mentioned in the 0.92 JSP spec, became influential amongst Java web developers as a better way to construct applications closer to the tenets of MVC. JavaWorld perhaps had the most sticky article of the time For some Java developers, this was the first time they had been exposed to MVC.

Later, the first big web framework in the Java community to embrace Model 2 wwould be Struts 1.0. Indeed, Struts was the poster child of Model 2 architecture.

In retrospect It was really only a small advance, but it heralded a shift away from each server-side generated page being its own thing, to pages being part of a larger design with a front-controller orchestrating. There is another writeup at Amero Publishing that seems to be an excerpt from a book of theirs.

Pattern Elements

  • Model: Java Beans
  • View: JSP Pages
  • Controller: A Servlet (later framework) with routing built in

1998 SWING

Java's Swing was a full MVC thick-client library developed originally by Netscape in 1996 as "Internet Foundation Classes", and donated to Sun soon after. It was merged with other technologies and launched as Swing. Wikipedia has a good write up of the origins.

The technology sat on top of the existing "Abstract Window Toolkit" (AWT), and provided a comprehensive set of controls for cross-platform UI construction. Models and Views were extendable. Controllers pulled things together. Decomposition was easy. Views could update models without controller particpation. Models, Views and Controllers could be instantiated semi-independently, which was important for testing. Testing wasn't a core activity until JUnit 1.0 in 1997, though.

2000 Struts

Struts 1 was an early Java web-framework in 2000 that honored the "Model 2" ideals. It had a lot of XML configuration.

2001 Drupal

Drupal is a content management framework and the core installation can serve as a simple web site, a single or multi-user blog, an Internet forum, or a community web site providing for user-generated content.

The framework has been around for a long time and different versions will reflect different MVC designs.

Drupal is very much a PAC architecture.
Larry Garfield

2001? MVA

It is not certain which are differences between this pattern and MVP.

The pattern arranges model, adapter (mediating controller) and view linearly without any connections whatsoever directly between model and view.

The MVC design used by Cocoa implements the mediator pattern. The framework is well known for using MVA, however the documentation never uses that name, it is unclear who coined the name.

Giving so much responsibility to a singel object, the mediating controller, has been jokingly refered to as Massive View Controller.

Pattern Elements

  • Model:
  • View: Is completely decoupled from the Model.
  • Adapter: AKA mediating controller

2004 Presentation Model

Described by Martin Fowler in Development of Further Patterns of Enterprise Application Architecture

You must provide a synchronization mechanism between the Presentation Model and the View.

The communication can be set up in different ways:

  • The View references the Presentation Model
  • The Presentation Model references and observes the View.

Pattern Elements

  • Presentation Model: Stores state and logic, its an abstraction of the view.
  • View: Presentation behavior, utterly simple and mainly used to render.

2004 JSF

JSF 1.x was based upon the same core ideas as Struts 1.0 but with a few twists:

  • binding user actions to java method calls,
  • an ecosystem of reusable UI components

Some people called it an improvement over Model 2 architecture, but at its core there was no fundamental difference. The request was intercepted by a front controller, which created the model, the model was used to access data, then the request was forwarded to a view that usually read from the model.

Dennis Byrne

JSF went on to become a standard way of constructing Java web applications. Particularly the page decomposition aspects.

2004 Rails

On the architectural level, all the inspiration came from the Java world and from Martin Fowler's Patterns of Enterprise Application Architecture. That book had just come out in January of 2003 as I started working on Rails in mid-2003. So it was immensely helpful.

So was learning from Struts 1.x, and I believe WebWork was around at the time as well. I basically studied all the Java frameworks available at the time, and while I was disgusted by the implementation of the ideas, the ideas themselves were powerful. The appropriation of MVC into a request/response context as one of those powerful ideas.

David Heinemeier Hansson

Rails heralded a convention over configuration era, and caused a seismic shift in the world of web-application development.

2005 MVVM

Described by John Gossman from Microsoft in his blog post: Introduction to Model/View/ViewModel pattern for building WPF apps. From the beginning it was compared to Presentation Model and later, in 2008, J. Gossman posted:

My opinion at this point is the Model-View-ViewModel pattern is a WPF-specific version of the PresentationModel pattern.

An interesting observation made about MVVM is that it maps quite well to PAC. You can read about that in: 100 Model/View/ViewModels of Mt. Fuji

MVVM Key features:

  • Relies on data binding, a mechanism that gives you boilerplate synchronization code.
  • The ViewModel is easier to unit test compared to code-behind or event-driven code.

    The ViewModel, though it sounds View-ish is really more Model-ish, and that means you can test it without awkward UI automation and interaction.

MVVM Issues:

  • Declarative data binding can be harder to debug.
  • In very large apps, data binding can result in considerable memory consumption.
  • It can be overkill for simple UIs.

Pattern Elements

  • Model: It is the data or business logic, completely UI independent, that stores the state and does the processing of the problem domain.
  • View: Consists of the visual elements, the buttons, windows, graphics and more complex controls of a GUI. In simple examples, the View is data bound directly to the model.
  • View Model: The term means "Model of a View", and be thought of as abstraction of the view, but it also provides a specialization of the Model that the View can use for data-binding. It contains data-transformers that convert Model types into View types, and it contains Commands the View can use to interact with the Model.

2005 Cake PHP

2005 DJango

2006 Zend

2007 Silverlight

2007 Sproutcore

Developed by Apple and claims to have kicked off the JS-MVC movement, its inspired by Cocoa.

2008 APS.NET MVC

2009 Angular.js

AngularJS is a tool set for building the framework most suited to your application development. It is maintained by Google and the community.

Angular is not a framework, it's an HTML compiler

Misko Hevery, creator of Angular

In 2012 Angular was declared a Model View Whatever library through a post made in the AngularJS G+ account. It wasn't a very formal declaration, but it helped the term to take off.

2010 Backbone

2010 Knockout.js

JavaScript library developed by Microsoft that uses the MVVM pattern. Some call it a data binding library and is not wrong since that is a key feature of MVVM.

2011 Ember.js

Its an opinionated JavaScript framework that embraces the concept of convention over configuration. It was originally being developed as SproutCore 2.0, but it changed course, the announcement: Amber.js (formerly SproutCore 2.0) is now Ember.js
You can listen to some of the history in this panel discussion recorded at an Ember.js NYC meetup: Fireside Chat with Ember Core Team Members, June 2013

2012 MVW

It is the term used when a technology can't clearly be identified as MVP or MVVM.

Pattern Elements

  • Model:
  • View:
  • Whatever: Whatever works for you