Hubbry Logo
MetamodelingMetamodelingMain
Open search
Metamodeling
Community hub
Metamodeling
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Metamodeling
Metamodeling
Metamodeling
View on Wikipedia
from Wikipedia

Example of a Geologic map information meta-model, with four types of meta-objects, and their self-references.[1]

A metamodel is a model of a model, and metamodeling is the process of generating such metamodels. Thus metamodeling or meta-modeling is the analysis, construction, and development of the frames, rules, constraints, models, and theories applicable and useful for modeling a predefined class of problems. As its name implies, this concept applies the notions of meta- and modeling in software engineering and systems engineering. Metamodels are of many types and have diverse applications.[2]

Overview

[edit]

A metamodel/ surrogate model is a model of the model, i.e. a simplified model of an actual model of a circuit, system, or software-like entity.[3][4] Metamodel can be a mathematical relation or algorithm representing input and output relations. A model is an abstraction of phenomena in the real world; a metamodel is yet another abstraction, highlighting the properties of the model itself. A model conforms to its metamodel in the way that a computer program conforms to the grammar of the programming language in which it is written. Various types of metamodels include polynomial equations, neural networks, Kriging, etc. "Metamodeling" is the construction of a collection of "concepts" (things, terms, etc.) within a certain domain. Metamodeling typically involves studying the output and input relationships and then fitting the right metamodels to represent that behavior.

Common uses for metamodels are:

  • As a schema for semantic data that needs to be exchanged or stored
  • As a language that supports a particular method or process
  • As a language to express additional semantics of existing information
  • As a mechanism to create tools that work with a broad class of models at run time
  • As a schema for modeling and automatically exploring sentences of a language with applications to automated test synthesis
  • As an approximation of a higher-fidelity model for use when reducing time, cost, or computational effort is necessary

Because of the "meta" character of metamodeling, both the praxis and theory of metamodels are of relevance to metascience, metaphilosophy, metatheories and systemics, and meta-consciousness. The concept can be useful in mathematics, and has practical applications in computer science and computer engineering/software engineering. The latter are the main focus of this article.

Topics

[edit]
Meta-Object Facility Illustration
A US FEA Business reference model[5]
Example of an ontology
A DoDAF metamodel

Definition

[edit]

In software engineering, the use of models is an alternative to more common code-based development techniques. A model always conforms to a unique metamodel. One of the currently most active branches of Model Driven Engineering is the approach named model-driven architecture proposed by OMG. This approach is embodied in the Meta Object Facility (MOF) specification.[citation needed]

Typical metamodelling specifications proposed by OMG are UML, SysML, SPEM or CWM. ISO has also published the standard metamodel ISO/IEC 24744.[6] All the languages presented below could be defined as MOF metamodels.

Metadata modeling

[edit]

Metadata modeling is a type of metamodeling used in software engineering and systems engineering for the analysis and construction of models applicable and useful to some predefined class of problems. (see also: data modeling).

Model transformations

[edit]

One important move in model-driven engineering is the systematic use of model transformation languages. The OMG has proposed a standard for this called QVT for Queries/Views/Transformations. QVT is based on the meta-object facility (MOF). Among many other model transformation languages (MTLs), some examples of implementations of this standard are AndroMDA, VIATRA, Tefkat, MT, ManyDesigns Portofino.

Relationship to ontologies

[edit]

Meta-models are closely related to ontologies. Both are often used to describe and analyze the relations between concepts:[7]

  • Ontologies: express something meaningful within a specified universe or domain of discourse by utilizing grammar for using vocabulary. The grammar specifies what it means to be a well-formed statement, assertion, query, etc. (formal constraints) on how terms in the ontology’s controlled vocabulary can be used together.[8]
  • Meta-modeling: can be considered as an explicit description (constructs and rules) of how a domain-specific model is built. In particular, this comprises a formalized specification of the domain-specific notations. Typically, metamodels are – and always should follow - a strict rule set.[9] "A valid metamodel is an ontology, but not all ontologies are modeled explicitly as metamodels."[8]

Types of metamodels

[edit]

For software engineering, several types of models (and their corresponding modeling activities) can be distinguished:

Zoos of metamodels

[edit]

A library of similar metamodels has been called a Zoo of metamodels.[11] There are several types of meta-model zoos.[12] Some are expressed in ECore. Others are written in MOF 1.4 – XMI 1.2. The metamodels expressed in UML-XMI1.2 may be uploaded in Poseidon for UML, a UML CASE tool.

See also

[edit]

References

[edit]

Further reading

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Metamodeling

View on Grokipedia
from Grokipedia
Metamodeling is the discipline concerned with the design, formalization, and development of metamodels, which are models that specify the structure, syntax, semantics, and constraints of other models, enabling the creation of languages in fields such as and conceptual modeling. In (MDE), metamodeling serves as a foundational technique for defining modeling languages, where a metamodel acts as an instance of a higher-level metametamodel, such as the Meta-Object Facility (MOF) standardized by the (OMG), allowing models to conform to precise rules for and tool generation. This approach facilitates abstraction by describing how models can be constructed, much like a defines a , and is essential for generating , validating models, and supporting transformations in automated development processes. Key concepts in metamodeling include the distinction between abstract syntax (defining model elements and relationships) and concrete syntax (specifying notations like diagrams), often realized through platforms such as ADOxx, which originated from research at the and supports interdisciplinary applications. Historically, metamodeling gained prominence in the late 1990s and early 2000s with the rise of MDE and the (MDA) paradigm promoted by the OMG, building on earlier ideas from and to address complexities in large-scale system design. Notable applications span for defining languages like UML, for customizing notations, and even hardware design for reuse through abstracted representations. In scientific computing, metamodeling also refers to surrogate models that approximate complex simulations to reduce computational demands, though this usage is more specialized and distinct from the primary modeling context. Overall, metamodeling enhances productivity by enabling reusable, formal descriptions of modeling practices across diverse domains, from to planning.

Fundamentals

Definition and Purpose

Metamodeling is the process of constructing a model that defines the elements, rules, and constraints of a itself, thereby specifying the abstract syntax, semantics, and structure necessary for creating valid models within that language. This approach treats modeling languages as subjects of modeling, allowing for the precise definition of how models can be formed and interpreted. The primary purpose of metamodeling is to enable the creation of reusable and standardized definitions for modeling languages, which underpins (MDE) by facilitating the development of domain-specific languages and automated tool support. It promotes among diverse modeling tools and platforms by establishing common metamodels that ensure models adhere to consistent rules, thereby streamlining processes such as validation and integration across systems. A key distinction exists between modeling and metamodeling: models operate at the M1 level of the modeling , describing domain-specific instances or entities (e.g., a UML representing software components), while metamodels reside at the M2 level, defining the rules and constructs that govern those models (e.g., the UML metamodel specifying what constitutes a valid ). This separation establishes a foundational where the level represents real-world instances conforming to M1 models. Fundamental benefits of metamodeling include the provision of layers that reduce in large-scale systems, enhance consistency in model creation and usage, and enable automation of downstream processes such as code generation and model transformations. By formalizing these layers, metamodeling supports scalable engineering practices that improve productivity and maintainability without delving into implementation-specific details.

Historical Development

The roots of metamodeling trace back to the 1970s in , where early efforts focused on metadata concepts and conceptual modeling to represent structures and relationships more semantically. Peter Chen introduced the entity-relationship (ER) model in , providing a foundational framework for diagramming entities, attributes, and relationships in , which laid groundwork for higher-level abstractions in modeling. This period also saw the emergence of (CASE) tools that incorporated metadata services for managing about , influencing subsequent metamodeling practices. The 1980 Pingree Park Workshop on , , and Conceptual Modeling further solidified these ideas by uniting researchers from , database management, and programming languages to discuss unified approaches to modeling real-world semantics. The formalization of metamodeling accelerated in the 1990s through the (OMG), which sought standardized frameworks for software modeling. In parallel with the development of the (UML), the OMG issued a request for proposals leading to the Meta-Object Facility (MOF), a language for defining metamodels; MOF version 1.0 was adopted in November 1997, establishing a four-layer architecture (M0: data, M1: models, M2: metamodels, M3: meta-metamodel) that enabled self-describing modeling languages. This adoption coincided with UML 1.1's standardization, marking metamodeling's shift from ad hoc database techniques to a rigorous, layered paradigm for . The evolution from ER modeling to this layered metamodeling emphasized semantic richness and reusability, transforming static data diagrams into dynamic, extensible model definitions. The 2000s expanded metamodeling through the OMG's (MDA), formally introduced in 2001 to promote platform-independent models transformed into executable code via metamodel standards like MOF and UML. French researcher Jean Bézivin played a pivotal role, coining the term (MDE) around 2005 and advocating for metamodel-based transformations and open standards to handle complex, evolving software systems. Bézivin's work, including foundational papers on MDE principles like direct representation and automation, influenced widespread adoption of metamodeling in industry and academia. This era built on foundations, emphasizing metamodels as enablers for automated model-to-model and model-to-code generation. In the , metamodeling integrated deeply with domain-specific languages (DSLs), enabling tailored modeling environments through metamodel extensions and composition techniques. Frameworks like Eclipse Modeling Framework (EMF) facilitated DSL development by defining metamodels that generated editors and interpreters, as seen in case studies for and real-time systems. Post-2020 developments have incorporated AI-assisted metamodeling for automated and validation, such as in IoT interoperability testing, alongside integrations with technologies for enhanced knowledge representation—paralleling ontology evolutions in semantic modeling. These advances, up to 2025, focus on scalability for and AI-driven systems while maintaining MOF-compliant architectures.

Core Concepts

Metadata Modeling

In metamodeling, metadata serves as self-describing information that captures the structure, semantics, and constraints of models, enabling them to represent data about data in a formalized manner. Metamodels act as the foundational schemas that define how this metadata is organized, stored, and retrieved, ensuring consistency and across modeling tools and environments. For instance, the Meta Object Facility (MOF) standard from the (OMG) establishes metamodeling as a means to create information models specifically for metadata, allowing models to be expressed in a way that supports tool-independent representation and manipulation. Key techniques in metadata modeling leverage reflective metamodels, which enable models to introspect and query their own structure dynamically. Through reflection, elements within a model can access meta-level information—such as classes, properties, and operations—facilitating runtime and self-description without external dependencies. This is particularly evident in MOF's reflection package, which provides operations like getMetaClass() to traverse metalayers and discover metadata. In repositories, these techniques support essential functions like , where metadata tracks changes across model iterations, and validation, ensuring compliance with metamodel constraints before storage or interchange. Practical examples illustrate metadata modeling's application. In database contexts, relational schemas are represented via metamodels that abstract tables as entity types, columns as attributes, and keys as constraints, as seen in unified frameworks like U-Schema, which maps relational structures (e.g., schemas) to a common metamodel for logical representation. Similarly, XML-based standards such as the (XMI) utilize metamodels to serialize and exchange model metadata, defining XML elements and attributes that conform to MOF-compliant schemas for seamless tool interoperability. A primary challenge in metadata modeling arises in large-scale systems, where achieving completeness—capturing all necessary descriptive elements across multiple levels—must balance against , which can lead to inconsistent representations and inefficient storage. Without unified manipulation mechanisms, such as homogeneous languages for and metadata operations, systems risk fragmented metadata that hinders extensibility and , particularly in environments like distributed databases or quality-of-service managers.

Model Transformations

Model transformations in metamodeling refer to automated processes that map instances conforming to a source metamodel to instances conforming to a target metamodel, enabling the conversion of models from one representation to another within (MDE). These include model-to-model (M2M) transformations, which produce a new model as output, and model-to-text (M2T) transformations, which generate textual artifacts such as code or documentation from a model. In MDE, such transformations operate at the instance level while respecting the structural constraints defined by the metamodels, ensuring and semantic consistency during the mapping. Key techniques for implementing model transformations emphasize rule-based approaches, where declarative rules specify correspondences between source and target elements. A prominent example is the ATLAS Transformation Language (ATL), a hybrid language that combines declarative matching rules with imperative constructs for complex manipulations, allowing transformations from one or more source models to target models. For synchronization scenarios, bidirectional transformations maintain consistency between paired models by propagating changes in either direction, often using lenses or relational models to handle updates without data loss or conflicts. These techniques are typically executed by transformation engines that interpret or compile the rules against the metamodels. Formally, transformation rules can be defined as mappings between metamodel elements, such as a function f:S→Tf: S \to T, where SS is the source metamodel and TT is the target metamodel, with each rule specifying how elements in SS are related to elements in TT through and output generation. This formalization ensures that transformations are composable and verifiable, often leveraging typed graph or for soundness. In MDE applications, model transformations automate code generation by converting platform-independent models to platform-specific implementations, reducing manual coding efforts in pipelines. They also facilitate refactoring by applying rules to models, improving quality without altering observable behavior, as seen in tools that migrate legacy models to modern architectures. Additionally, transformations enable by mapping models across heterogeneous domains, such as converting UML diagrams to database schemas for seamless .

Relationship to Ontologies

Metamodeling and ontologies both serve as higher-order abstractions for knowledge representation, but they address distinct aspects of modeling. Metamodels, such as those defined in the Object Management Group's Meta-Object Facility (MOF), provide a structural foundation for defining modeling languages, specifying syntax, constraints, and well-formedness rules at the M2 layer of the four-layer architecture. In contrast, ontologies, exemplified by the (OWL), focus on semantic domain knowledge, capturing concepts, relationships, and axioms to enable reasoning about real-world entities. This distinction positions metamodels as prescriptive frameworks for model construction, while ontologies offer descriptive vocabularies for domain interpretation. Synergies between metamodeling and ontologies arise in hybrid approaches that leverage their complementary strengths. For instance, ontology-driven metamodeling integrates ontologies to enrich metamodel semantics, enabling semantic validation and consistency checking beyond syntactic rules. The Ontology Definition Metamodel (ODM), standardized by the OMG, exemplifies this by providing MOF-based metamodels for ontology languages like and RDF, facilitating the use of ontologies within model-driven architectures for enhanced and reasoning. Such integrations allow ontologies to extend metamodels with inferential capabilities, supporting applications like policy-based systems where domain knowledge informs model evolution. Key differences highlight their divergent priorities: metamodels emphasize syntax and structural conformance to ensure models adhere to defined languages, whereas ontologies prioritize and reasoning, such as through subsumption hierarchies that deduce implicit relationships from explicit assertions. Metamodels operate under a , prescribing valid instances, while ontologies adopt an open-world view, describing possible realities without exhaustive constraints. These contrasts became more pronounced in the 2000s with the parallel development of and the . Practical examples of their integration appear in tools, where RDF serves as a metamodel for storing and querying , enabling seamless representation of constructs as instances of MOF-compliant models. This approach supports by mapping domain semantics to metamodel structures, as seen in tools like Protégé that incorporate ODM for UML-based visualization and validation.

Architectures and Types

Metamodeling Architectures

Metamodeling architectures provide structured frameworks for defining and organizing models at multiple abstraction levels, enabling consistent representation and manipulation of metadata. The most widely adopted architecture is the (OMG)'s four-layer metamodeling , which separates concerns between data instances, models, metamodels, and meta-metamodels to support scalable . In this architecture, the layer contains raw data or object instances that conform to models at the M1 layer, such as specific UML diagrams or domain-specific instances. The M1 layer consists of models that define the structure and semantics for M0 instances, while the layer holds metamodels that specify the language or rules for creating M1 models, exemplified by the UML metamodel itself. At the apex, the M3 layer features meta-metamodels, which provide a universal schema for defining all lower-level metamodels, with the Meta Object Facility (MOF) serving as the foundational standard in this role. Key components of these architectures include the meta-metamodel as a reflective foundation, allowing self-description of modeling elements through operations like and dynamic modification. For instance, Ecore in the Modeling Framework implements this as a lightweight meta-metamodel compatible with MOF, functioning as a universal schema for Eclipse-based tools by providing a reflective for generic model manipulation and persistence. Conformance levels ensure tool : implementations must support at least the Essential MOF (EMOF) subset for basic modeling or the Complete MOF (CMOF) for advanced features like associations and generalizations. The MOF standard, first formalized in version 1.4 in 2002, evolved significantly with in 2006 to align more closely with UML 2, introducing EMOF as a simplified, essential subset for lightweight metamodeling and CMOF as an extension for complete, UML-equivalent capabilities including constraints and actions. Subsequent versions, up to the current 2.5.1 released in 2016, enhanced reflective capabilities—such as generic model querying and modification—and extension mechanisms, including profile-based customizations and integration with (XMI) for , without major architectural overhauls. These updates emphasize modularity, enabling tools to extend MOF through reflective metamodeling while maintaining .

Types of Metamodels

Metamodels can be classified based on their purpose and execution capabilities into declarative and executable types. Declarative metamodels focus on defining the abstract syntax and static semantics of modeling languages, typically using standards like the Meta-Object Facility (MOF) or Ecore, without inherent support for behavioral execution; for instance, the UML metamodel exemplifies this by specifying structural elements and constraints via the (OCL). In contrast, executable metamodels extend declarative ones by incorporating through action languages, enabling simulation and interpretation of models; tools like Kermeta facilitate this by adding domain-specific behaviors to metamodels. Another key classification distinguishes domain-specific metamodels (DSMMs) from general-purpose ones. DSMMs tailor modeling constructs to particular application domains, providing specialized elements that enhance expressiveness and within that scope, such as predefined classes, relations, and constraints for business processes or enterprise architectures. General-purpose metamodels, like those underlying UML class diagrams, offer broad applicability across domains with minimal core elements (e.g., classes, attributes, associations), but they require more effort to adapt to specific needs due to their lack of domain-tailored notation. Prominent types of metamodels include kernel metamodels, profile-based metamodels, and linguistic metamodels. Kernel metamodels provide a minimal abstract syntax as a foundational framework for managing user-defined modeling languages, supporting core operations like model creation, element manipulation, and serialization via standards such as XMI; frameworks like Coral implement this as a metamodel-independent kernel with extensions for dynamic hierarchies. Profile-based metamodels extend existing general-purpose metamodels, particularly UML, through lightweight mechanisms like stereotypes, tagged values, and constraints to accommodate domain-specific needs without altering the core metamodel; this approach enables flexible projections and combinations of extensions for specialized applications. Linguistic metamodels define the syntax and grammar for domain-specific languages (DSLs), focusing on the structural rules that govern model construction, distinct from ontological metamodels that emphasize domain concepts; they are essential for creating DSLs by specifying abstract syntax hierarchies. Metamodels also vary in characteristics related to and . Strict enforces precise conformance where models adhere exactly to definitions, leveraging for safe specialization and polymorphism while maintaining through covariant and contravariant rules. Loose , conversely, permits greater flexibility, such as models conforming to multiple metaclasses or allowing implicit conversions, which supports but may introduce conformance ambiguities. Regarding , static metamodels treat structures as fixed, limiting adaptability, whereas dynamic ones support ongoing changes through co-evolution mechanisms that propagate metamodel modifications to conforming models without disruption. Representative examples illustrate these classifications in practice. The (BPMN) metamodel is a declarative, domain-specific type tailored for business processes, defining elements like tasks, events, and gateways to model workflows. Similarly, the (SysML) metamodel extends UML as a profile-based, domain-specific metamodel for , incorporating diagrams for requirements, structure, and behavior in complex system design. These types often build upon established metamodeling architectures like the OMG four-layer stack to ensure .

Applications and Examples

Practical Applications

Metamodeling finds extensive application in , where it enables the creation of domain-specific languages (DSLs) and automated code generation. For instance, the Modeling Framework (EMF) is widely used to define metamodels that drive plugin development in the IDE, allowing developers to generate code from abstract syntax trees and ensure consistency across large-scale projects. This approach has been instrumental in projects like the tool for UML modeling, reducing manual coding efforts by providing a structured way to handle model evolution. EMF supports cloud-native applications through EMF Cloud. In , metamodeling underpins tools that standardize and automate workflow designs. The (BPMN) standard relies on metamodels to define executable processes, with tools like Modeler using metamodel-driven validation to simulate and deploy without errors. A notable example is its integration in (ERP) systems, where metamodels facilitate the transformation of process models into deployable artifacts, enhancing agility in industries such as and . Key tools and frameworks exemplify metamodeling's practicality up to 2025. Eclipse EMF, part of the Eclipse Modeling Project, supports Ecore as its core metamodeling language, enabling the generation of editors and serializers for custom models. MetaEdit+, a commercial tool, allows visual definition of metamodels for , with case studies showing its use in embedded systems design at companies like , where it accelerated product customization. Open-source alternatives like the Graphical Modeling Framework (GMF), also Eclipse-based, extend EMF for diagram generation. Model-driven architecture (MDA) in automotive design leverages metamodeling for system-level simulations. Using SysML metamodels, tools like Cameo Systems Modeler generate code for vehicle control systems from high-level designs. This has streamlined the transition from requirements to implementation, cutting iteration cycles significantly, and supports compliance with safety standards like ISO 26262. In healthcare, metamodeling supports data interoperability through standards like HL7 FHIR, where metamodels define resource structures for electronic health records (EHRs). The HL7 metamodel enables tools such as the HAPI FHIR server to map diverse data formats, facilitating secure data exchange across hospitals. Overall, metamodeling in (MDE) projects yields measurable benefits, attributed to automated generation and error reduction in complex systems, as noted by the (OMG). These gains are particularly evident in regulated sectors, where metamodel-driven validation minimizes compliance risks.

Metamodel Zoos and Repositories

Metamodel zoos represent curated libraries of reusable metamodels within (MDE), serving as foundational resources for testing transformation tools, fostering , and promoting diversity in modeling languages akin to biological model zoos that preserve ecosystem variety. These collections typically include metamodels from various domains, ranging from simple structures with fewer than 10 meta-classes to complex ones exceeding 280 meta-classes, enabling systematic evaluation of MDE artifacts. Prominent repositories include those aligned with Object Management Group (OMG) standards, such as MOF-based systems that support layered architectures from meta-metamodels (M3) to data (M0), incorporating components like metadata managers, transaction handlers, and XMI import/export for persistent storage of metamodels. Open platforms like host extensive metamodel collections, with topics such as "metamodeling" encompassing public repositories for sharing Modeling Framework (EMF) Ecore models. The ecosystem features the Atlanmod , a dedicated repository of standard EMF models—including those for , Cobol, and social networks—designed for easy integration into projects via Maven artifacts or plugins, with ongoing updates as evidenced by 2025 analyses of meta-model duplication across 30,000 -extracted metamodels. Additionally, platforms like MDEForge provide extensible web-based repositories tailored for community-driven MDE artifact storage, including metamodels with dedicated metamodels for repository governance. Standards for sharing metamodels emphasize XML Metadata Interchange (XMI), an OMG specification that serializes metamodels into XML formats, mapping MOF constructs to elements and attributes while supporting references via IDREFs and UUIDs for lossless exchange across tools. XMI facilitates interoperability by enabling validation through XML Schemas, namespace-based multiple model handling, and extensions for model fragments, ensuring consistent object identity in collaborative environments. Versioning and governance in these repositories address concurrent evolution of metamodels and models through operation-based tracking and tools like COPE, which record editor operations enriched with semantics to manage changes without independent treatment of metamodel and model versions. Systems such as ChronoSphere integrate versioning with metamodel evolution, supporting multi-user access and consistency checks to govern repository integrity. These zoos and repositories play a crucial role in MDE communities by enabling metamodel reuse, as seen in automated classification and clustering tools that organize repositories for efficient retrieval. They support benchmarking of transformation languages like ATL through dedicated zoos, allowing empirical studies on feature usage across hundreds of examples. Furthermore, they facilitate evolution tracking by detecting metamodel changes in project repositories, aiding in the maintenance of long-lived MDE ecosystems. Recent advancements include metamodeling support for in , aligning with OMG's standard as of 2025.

References

  1. https://www.unifr.ch/inf/digits/en/research/topics/metamodeling.html
  2. https://wiki.eclipse.org/images/a/ad/OMCW_chapter02_IntroductionToMetamodelling.York.pdf
  3. https://www.oreilly.com/library/view/model-driven-software-development/9781118725764/OEBPS/c06.htm
  4. https://www.computer.org/csdl/magazine/dt/2009/03/mdt2009030096/13rRUy3gmWk
  5. https://www.sciencedirect.com/topics/computer-science/metamodeling
  6. https://arxiv.org/pdf/1409.2359
  7. https://www.omg.org/spec/MOF/2.5.1/About-MOF
  8. https://www.site.uottawa.ca/~tcl/gradtheses/mnojoumian/ThesisFiles/FinalSpec/MOF/6.2.html
  9. https://link.springer.com/chapter/10.1007/978-3-540-30577-4_40
  10. https://dl.acm.org/doi/10.1145/320434.320440
  11. https://www.ewsolutions.com/metadata-history/
  12. https://dl.acm.org/doi/10.1145/800227.806902
  13. https://www.omg.org/spec/MOF/ISO/19502/PDF
  14. https://link.springer.com/chapter/10.1007/978-3-642-59412-0_17
  15. http://www.omg.org/mda/executive_overview.htm
  16. https://arxiv.org/html/2405.18539v1
  17. https://link.springer.com/chapter/10.1007/11877028_2
  18. https://dl.acm.org/doi/10.1145/2060329.2060364
  19. https://ieeexplore.ieee.org/document/5441292/
  20. https://www.mdpi.com/1424-8220/23/21/8730
  21. https://www.researchgate.net/publication/354874018_Conceptual_modeling_in_the_era_of_Big_Data_and_Artificial_Intelligence_Research_topics_and_introduction_to_the_special_issue
  22. https://www.omg.org/spec/MOF/2.5.1/PDF
  23. https://www.sciencedirect.com/science/article/pii/S0306437921001149
  24. https://www.omg.org/spec/XMI
  25. https://www.researchgate.net/publication/228539763_Models_for_metadata_or_metamodels_for_data
  26. https://www.researchgate.net/publication/221223520_Model_Transformations_Transformation_Models
  27. https://www.sciencedirect.com/science/article/abs/pii/B9780123965264000035
  28. https://www.researchgate.net/publication/213882827_Transforming_models_with_ATL
  29. https://homepages.inf.ed.ac.uk/perdita/gttse.pdf
  30. https://www.researchgate.net/publication/221496609_Model-driven_Software_Refactoring
  31. https://www-docs.b-tu.de/fg-internet-technologie/public/publications/IT/Research/AssmannZW06.pdf
  32. https://ece.northeastern.edu/fac-ece/kokar/publications/KokarOntologiesMetamodelingv2.pdf
  33. https://www.jot.fm/issues/issue_2005_01/article3.pdf
  34. https://www.eclipse.org/modeling/emf/docs.html
  35. https://www.omg.org/spec/MOF/2.0/PDF
  36. https://centralesupelec.hal.science/hal-00905067/document
  37. https://link.springer.com/chapter/10.1007/978-3-642-36089-3_11
  38. http://knut.hinkelmann.ch/lectures/ABIT2016/ABIT%2007%20Metamodeling.pdf
  39. https://www.cs.kent.ac.uk/projects/kmf/mdaworkshop/submissions/Porres.pdf
  40. http://www.lcc.uma.es/~av/MDD-MDA/presentaciones/uml_profiles_vs_metamodel.pdf
  41. https://www.infoq.com/news/2008/04/mde-combining-gpl-and-dsl/
  42. https://www.scitepress.org/Papers/2014/47139/47139.pdf
  43. https://ceur-ws.org/Vol-1090/2.pdf
  44. https://eclipse.dev/emfcloud/
  45. https://www.iso.org/standard/68383.html
  46. https://hapifhir.io/
  47. https://www.omg.org/mda/
  48. https://ceur-ws.org/Vol-1077/amt13_submission_4.pdf
  49. https://www.researchgate.net/publication/221237914_Architecture_of_OMG_MOF-based_repository_systems
  50. https://github.com/topics/metamodeling
  51. https://github.com/atlanmod/zoo
  52. https://dl.acm.org/doi/abs/10.1145/3771765
  53. https://github.com/MDEGroup/MDEForge
  54. https://www.omg.org/spec/XMI/2.5.1/PDF
  55. https://www.jot.fm/issues/issue_2012_10/article1.pdf
  56. https://ieeexplore.ieee.org/document/5071722
  57. https://www.researchgate.net/publication/322009543_Combining_Versioning_and_Metamodel_Evolution_in_the_ChronoSphere_Model_Repository
  58. https://www.researchgate.net/publication/337527666_Automated_Classification_of_Metamodel_Repositories_A_Machine_Learning_Approach
  59. https://ieeexplore.ieee.org/document/8101244/
  60. https://www.jot.fm/contents/issue_2020_02/article14.html
  61. https://www.omg.org/spec/DT/1.0/About-Digital-Twin
Add your contribution
Related Hubs
User Avatar
No comments yet.