Model View Definition

[Danel Potvin]

IFC aims to create an interface among various tools to exchange information. However, not each program has an internal data schema that stores all specific classes in each domain. Let us remind that there are about 12000 of them.

It should, therefore, be clarified which subset of all IFC schema data is needed during the exchange for a specific application. In other words, which information needs to be filtered from the entire IFC schema.

BuildingSmart certification for programs involves the import and export of IFC according to the model view definition and not the full IFC schema. Software providers can also define their own subset or filter, namely their own MVD. They can develop MVDs to exchange data necessary for energy or evacuation simulations. In this case, it will be preferable to include such an MVD containing, for instance, an occupant class ifcOccupant (essential for creating an object evacuation simulation).

In the openBIM workflow there is no single central model that everyone can access and modify as they like. Every project participant has their own model, of which they are the sole author. These models, or copies of them, are then exchanged at agreed intervals.

So, we can divide the BIM process into two realms: Firstly, we have the native authoring environment where models are created and edited (this is the private domain of each discipline). Secondly, we have the collaborative environment where IFC copies of these models are viewed and coordinated.

In this setup, no-one can access or change the model content of another discipline. There are clear lines of communication. If changes to a model are required, these are tracked and reported on. This was discussed in a previous video.

More than this, in an openBIM workflow, we can predefine exactly what information needs to be transferred when and by whom. This is achieved with Model View Definitions, or MVDs. An MVD is essentially a filtered view of the IFC. It allows users to export specific packages of model information to meet a particular use.

Urban infrastructure systems present a complex interplay of interconnected domains, each utilizing distinct data formats, hindering seamless data flow and unified information models. To tackle interoperability challenges, Information Delivery Manuals (IDM) and Model View Definitions (MVD) have been developed. However, the complexities in infrastructure systems and their complex interrelations cause challenges in creating urban level IDM/MVDs. IDMs and MVDs are developed within the Building Information Modeling (BIM) domain, that are represented under the Industry Foundation Classes (IFC). The process of creating MVDs lack a consistent development framework, resulting in heterogeneous and inconsistent definitions of model views.

At infrastructure level, designing, engineering, constructing, and maintaining systems can be challenging, as they involve diverse functionalities that require seamless data exchange and sharing. Unfortunately, this is hindered by a heterogeneous environment that prevents easy data sharing and integration. Although there are data exchange standards for individual infrastructure systems, they mostly cover intrinsic interactions within a single infrastructure, rather than extrinsic interactions between multiple systems.

This dissertation aims to address these issues by facilitating IDM/MVD development and providing a basis for creating a standardized approach for developing IDMs and MVDs at urban scale. The study proposes a framework to semantically modularize infrastructure systems, identify relationships via Design Structure Matrices (DSM), and construct IDMs. An entity-based integration approach is also proposed, allowing for the generation of encapsulated MVD concept modules from integrated libraries. The objective to streamline MVD development by facilitating access to pre-developed concepts and ensuring consistency across domains. And finally, it introduces an ontology-based framework aimed to facilitate urban-level data interoperability by integrating different infrastructure data exchange standards. The framework offers a unified infrastructure information model, enabling representation of urban-scale interactions.

By bridging the gap between different infrastructure systems and promoting compatibility on a citywide level, the suggested framework marks a significant change in urban planning and development. It enables stakeholders to establish innovative links between functions at different levels of organization, leading to more efficient resource usage and greater resilience for smart cities.

Shariatfar, Moeid, "Facilitating Model View Definition Development for Data Interoperability in Urban Infrastructure Systems Using Design Structure Matrices and Ontology" (2024). LSU Doctoral Dissertations. 6436.
_dissertations/6436

I have been using the Zend Framework with an MVC configuration, read about Ruby on Rails and I plan to explore other MVC frameworks in Python (Django?). I really like the way it isolates some parts of the logic, security, and validation. But after just one year of using it I read an answer here saying that almost everyone has a wrong definition of MVC and that made me wonder: What is the Right definition of MVC and where could I read about the pattern and standard implementations?

Update: I understand we all know the BASIC definition (there's a model a controller and a view, the actions on the controller go to the view with some info after making something with the model) but I would love to know what is the definition you THINK everyone KNOWS and why is it wrong (and maybe that will explain to everyone where there could be mistakes, opinions, and of course what is your real point of view of this)

This is often the way things work in a smaller application but reality MVC is a way to seperate the Business code from the presentation code. The Model does all the real business work. The views provide the look and feel, and the controller maps one to the other.

"Model View Controller (MVC) is one of the most quoted (and most misquoted) patterns around. It started as a framework developed by Trygve Reenskaug for the Smalltalk platform in the late 1970s. Since then it has played an influential role in most UI frameworks and in the thinking about UI design."

Of these the separation of presentation and model is one of the most important design principles in software, and the only time you shouldn't follow it is in very simple systems where the model has no real behavior in it anyway. As soon as you get some nonvisual logic you should apply the separation. Unfortunately, a lot of UI frameworks make it difficult, and those that don't are often taught without a separation.

The separation of view and controller is less important, so I'd only recommend doing it when it is really helpful. For rich-client systems, that ends up being hardly ever, although it's common in Web front ends where the controller is separated out. Most of the patterns on Web design here are based on that principle."

I trust the MVC definition given here by Martin Fowler. However, you may want to notice the fact that more or less these framework have their own tweak in it. For example a framework like Django is more Model-Template-Controller due to its templating feature.

I believe the same thing. As far as I am concerned anything that manages to separate the concerns of the display, the data/business objects and the control of those (initialisation, responding to user input) gets the benefit that MVC seeks to provide.

The aim is to move these items into re-useable components and be able to swap different implementations in and out and also be able to test the individual pieces in isolation. IMO that's what MVC is all about.

MVC is one of three ASP.NET programming models. MVC is a framework for building web applications using a MVC (Model View Controller) design: The Model represents the application core (for instance a list of database records). The View displays the data (the database records).

Traditionally used for desktop graphical user interfaces (GUIs), this pattern became popular for designing web applications.[4] Popular programming languages have MVC frameworks that facilitate the implementation of the pattern.

One of the seminal insights in the early development of graphical user interfaces, MVC became one of the first approaches to describe and implement software constructs in terms of their responsibilities.[5]

In their final design, a model represents some part of the program purely and intuitively. A view is a visual representation of a model, retrieving data from the model to display to the user and passing requests back and forth between the user and the model. A controller is an organizational part of the user interface that lays out and coordinates multiple Views on the screen, and which receives user input and sends the appropriate messages to its underlying Views. This design also includes an Editor as a specialized kind of controller used to modify a particular view, and which is created through that view.[6]

Smalltalk-80 supports a version of MVC that evolved from this one.[6] It provides abstract view and controller classes as well as various concrete subclasses of each that represent different generic widgets. In this scheme, a View represents some way of displaying information to the user, and a controller represents some way for the user to interact with a view. A view is also coupled to a model object, but the structure of that object is left up to the application programmer. The Smalltalk-80 environment also includes an "MVC Inspector", a development tool for viewing the structure of a given model, view, and controller side-by-side.[9]

In 1988, an article in The Journal of Object Technology (JOT) by two ex-PARC employees presented MVC as a general "programming paradigm and methodology" for Smalltalk-80 developers. However, their scheme differed from both Reenskaug et al.'s and that presented by the Smalltalk-80 reference books. They defined a view as covering any graphical concern, with a controller being a more abstract, generally invisible object that receives user input and interacts with one or many views and only one model.[10]

c80f0f1006