Hubbry Logo
Modeling languageModeling languageMain
Open search
Modeling language
Community hub
Modeling language
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Modeling language
Modeling language
Modeling language
View on Wikipedia
from Wikipedia

A modeling language is a notation for expressing data, information or knowledge or systems in a structure that is defined by a consistent set of rules.

A modeling language can be graphical or textual.[1] A graphical modeling language uses a diagramming technique with named symbols that represent concepts and lines that connect the symbols and represent relationships and various other graphical notation to represent constraints. A textual modeling language may use standardized keywords accompanied by parameters or natural language terms and phrases to make computer-interpretable expressions. An example of a graphical modeling language and a corresponding textual modeling language is EXPRESS.

Not all modeling languages are executable, and for those that are, the use of them doesn't necessarily mean that programmers are no longer required. On the contrary, executable modeling languages are intended to amplify the productivity of skilled programmers, so that they can address more challenging problems, such as parallel computing and distributed systems.

A large number of modeling languages appear in the literature.

Type of modeling languages

[edit]

Graphical types

[edit]

Example of graphical modeling languages in the field of computer science, project management and systems engineering:

Examples of graphical modeling languages in other fields of science.

Textual types

[edit]

Information models can also be expressed in formalized natural languages, such as Gellish.[4] Gellish has natural language variants such as Gellish Formal English and Gellish Formal Dutch (Gellish Formeel Nederlands), etc. Gellish Formal English is an information representation language or semantic modeling language that is defined in the Gellish English Dictionary-Taxonomy, which has the form of a Taxonomy-Ontology (similarly for Dutch). Gellish Formal English is not only suitable to express knowledge, requirements and dictionaries, taxonomies and ontologies, but also information about individual things. All that information is expressed in one language and therefore it can all be integrated, independent of the question whether it is stored in central or distributed or in federated databases. Information models in Gellish Formal English consists of collections of Gellish Formal English expressions, that use natural language terms and formalized phrases. For example, a geographic information model might consist of a number of Gellish Formal English expressions, such as: 

- the Eiffel tower <is located in> Paris
- Paris <is classified as a> city

whereas information requirements and knowledge can be expressed for example as follows: 

- tower <shall be located in a> geographical area
- city <is a kind of> geographical area

Such Gellish Formal English expressions use names of concepts (such as "city") and phrases that represent relation types (such as ⟨is located in⟩ and ⟨is classified as a⟩) that should be selected from the Gellish English Dictionary-Taxonomy (or of your own domain dictionary). The Gellish English Dictionary-Taxonomy enables the creation of semantically rich information models, because the dictionary contains more than 600 standard relation types and contains definitions of more than 40000 concepts. An information model in Gellish can express facts or make statements, queries and answers.

More specific types

[edit]

In the field of computer science recently more specific types of modeling languages have emerged.

Algebraic

[edit]

Algebraic Modeling Languages (AML) are high-level programming languages for describing and solving high complexity problems for large scale mathematical computation (i.e. large scale optimization type problems). One particular advantage of AMLs like AIMMS, AMPL, GAMS, Gekko, Mosel, OPL, MiniZinc, and OptimJ is the similarity of its syntax to the mathematical notation of optimization problems. This allows for a very concise and readable definition of problems in the domain of optimization, which is supported by certain language elements like sets, indices, algebraic expressions, powerful sparse index and data handling variables, constraints with arbitrary names. The algebraic formulation of a model does not contain any hints how to process it.

Behavioral

[edit]

Behavioral languages are designed to describe the observable behavior of complex systems consisting of components that execute concurrently. These languages focus on the description of key concepts such as: concurrency, nondeterminism, synchronization, and communication. The semantic foundations of Behavioral languages are process calculus or process algebra.

Discipline-specific

[edit]

A discipline-specific modeling (DspM) language is focused on deliverables affiliated with a specific software development life cycle stage. Therefore, such language offers a distinct vocabulary, syntax, and notation for each stage, such as discovery, analysis, design, architecture, contraction, etc. For example, for the analysis phase of a project, the modeler employs specific analysis notation to deliver an analysis proposition diagram. During the design phase, however, logical design notation is used to depict the relationship between software entities. In addition, the discipline-specific modeling language best practices does not preclude practitioners from combining the various notations in a single diagram.

Domain-specific

[edit]

Domain-specific modeling (DSM) is a software engineering methodology for designing and developing systems, most often IT systems such as computer software. It involves the systematic use of a graphical domain-specific language (DSL) to represent the various facets of a system. DSM languages tend to support higher-level abstractions than General-purpose modeling languages, so they require less effort and fewer low-level details to specify a given system.

Framework-specific

[edit]

A framework-specific modeling language (FSML) is a kind of domain-specific modeling language which is designed for an object-oriented application framework. FSMLs define framework-provided abstractions as FSML concepts and decompose the abstractions into features. The features represent implementation steps or choices.

A FSML concept can be configured by selecting features and providing values for features. Such a concept configuration represents how the concept should be implemented in the code. In other words, concept configuration describes how the framework should be completed in order to create the implementation of the concept.

Information and knowledge modeling

[edit]

Linked data and ontology engineering require 'host languages' to represent entities and the relations between them, constraints between the properties of entities and relations, and metadata attributes. JSON-LD and RDF are two major (and semantically almost equivalent) languages in this context, primarily because they support statement reification and contextualisation which are essential properties to support the higher-order logic needed to reason about models. Model transformation is a common example of such reasoning.

Object-oriented

[edit]

A language for object-oriented modeling (OOM) is a notation for modeling a system as object-oriented. An organization may use OOM to document and describe the system architecture and design to both developers and stakeholders. Because a modeling language is visual and at a higher-level of abstraction than code, using models encourages the generation of a shared vision that may prevent problems of differing interpretation later in development. Often software modeling tools are used to construct these models, which may then be capable of automatic translation to code.

Virtual reality

[edit]

Virtual Reality Modeling Language (VRML), before 1995 known as the Virtual Reality Markup Language is a standard file format for representing 3-dimensional (3D) interactive vector graphics, designed particularly with the World Wide Web in mind.

Others

[edit]

Applications

[edit]

Various kinds of modeling languages are applied in different disciplines, including computer science, information management, business process modeling, software engineering, and systems engineering. Modeling languages can be used to specify:

  • system requirements,
  • structures and
  • behaviors.

Modeling languages are intended to be used to precisely specify systems so that stakeholders (e.g., customers, operators, analysts, designers) can better understand the system being modeled.

The more mature modeling languages are precise, consistent and executable. Informal diagramming techniques applied with drawing tools are expected to produce useful pictorial representations of system requirements, structures and behaviors, which can be useful for communication, design, and problem solving but cannot be used programmatically.[5]: 539  Executable modeling languages applied with proper tool support, however, are expected to automate system verification and validation, simulation and code generation from the same representations.

Quality

[edit]

A review of modelling languages is essential to be able to assign which languages are appropriate for different modelling settings. In the term settings we include stakeholders, domain and the knowledge connected. Assessing the language quality is a means that aims to achieve better models.

Framework for evaluation

[edit]

Here language quality is stated in accordance with the SEQUAL framework for quality of models developed by Krogstie, Sindre and Lindland (2003), since this is a framework that connects the language quality to a framework for general model quality. Five areas are used in this framework to describe language quality and these are supposed to express both the conceptual as well as the visual notation of the language. We will not go into a thorough explanation of the underlying quality framework of models but concentrate on the areas used to explain the language quality framework.

Domain appropriateness

[edit]

The framework states the ability to represent the domain as domain appropriateness. The statement appropriateness can be a bit vague, but in this particular context it means able to express. You should ideally only be able to express things that are in the domain but be powerful enough to include everything that is in the domain. This requirement might seem a bit strict, but the aim is to get a visually expressed model which includes everything relevant to the domain and excludes everything not appropriate for the domain. To achieve this, the language has to have a good distinction of which notations and syntaxes that are advantageous to present.

Participant appropriateness

[edit]

To evaluate the participant appropriateness we try to identify how well the language expresses the knowledge held by the stakeholders. This involves challenges since a stakeholder's knowledge is subjective. The knowledge of the stakeholder is both tacit and explicit. Both types of knowledge are of dynamic character. In this framework only the explicit type of knowledge is taken into account. The language should to a large extent express all the explicit knowledge of the stakeholders relevant to the domain.

Modeller appropriateness

[edit]

Last paragraph stated that knowledge of the stakeholders should be presented in a good way. In addition it is imperative that the language should be able to express all possible explicit knowledge of the stakeholders. No knowledge should be left unexpressed due to lacks in the language.

Comprehensibility appropriateness

[edit]

Comprehensibility appropriateness makes sure that the social actors understand the model due to a consistent use of the language. To achieve this the framework includes a set of criteria. The general importance that these express is that the language should be flexible, easy to organize and easy to distinguish different parts of the language internally as well as from other languages. In addition to this, the goal should be as simple as possible and that each symbol in the language has a unique representation.

This is in connection to also to the structure of the development requirements. .

Tool appropriateness

[edit]

To ensure that the domain actually modelled is usable for analyzing and further processing, the language has to ensure that it is possible to reason in an automatic way. To achieve this it has to include formal syntax and semantics. Another advantage by formalizing is the ability to discover errors in an early stage. It is not always that the language best fitted for the technical actors is the same as for the social actors.

Organizational appropriateness

[edit]

The language used is appropriate for the organizational context, e.g. that the language is standardized within the organization, or that it is supported by tools that are chosen as standard in the organization.

See also

[edit]

References

[edit]

Further reading

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Modeling language

View on Grokipedia
from Grokipedia
A modeling language is a formal notation that provides a structured means to specify, visualize, construct, and document the artifacts of software systems, business processes, and other complex systems through defined syntax and semantics. These languages enable the of real-world entities into models that capture essential properties, behaviors, and relationships, facilitating analysis, communication, and automation in development processes. In and , modeling languages play a central role in (MDE), where models serve as primary artifacts for design, verification, and generation of implementations. They differ from general-purpose programming languages by emphasizing declarative representations over imperative code, often using graphical or textual notations to bridge natural language specifications and executable systems. Prominent examples include the (UML), a standardized, general-purpose graphical language developed in the mid-1990s by , , and James Rumbaugh, and adopted by the (OMG) in 1997 for . Other key standards encompass the Systems Modeling Language (SysML), an extension of UML tailored for systems engineering with support for requirements, architecture, and simulation diagrams, and the Architecture Analysis and Design Language (AADL), focused on real-time embedded systems with strong emphasis on performance analysis. Beyond general-purpose languages, languages (DSMLs) are customized for particular application domains to enhance expressiveness, productivity, and correctness-by-construction. For instance, DSMLs in like the Future Airborne Capability Environment (FACE) standard define profiles for safety-critical software integration, while in , languages like the Model Description Language (MDL) support reusable hierarchical representations of computational models. The evolution of these languages has been driven by standards bodies such as OMG and , promoting interoperability, tool support, and formal semantics to address challenges in , , and verification across industries.

Overview

Definition and Characteristics

A modeling language is a formal or semi-formal notation for expressing models that abstractly represent systems, processes, or concepts in a structured manner. These languages enable the specification of complex ideas through consistent rules, facilitating communication and analysis among stakeholders. Core characteristics of modeling languages include syntax, which defines the rules governing the structure and validity of models; semantics, which provides the meaning and interpretation of syntactic elements; notation, encompassing the symbols, diagrams, or textual forms used to represent models; and expressiveness, referring to the language's capacity to capture and convey the complexity of the modeled domain without undue or verbosity. The abstract syntax outlines the conceptual elements and relationships independently of their visual or textual form, while concrete syntax specifies how these are rendered for human or machine use. Semantics can be formal, using mathematical mappings, or informal, relying on descriptions, to ensure precise understanding. In contrast to programming languages, which prioritize executability and low-level implementation details to generate runnable code, modeling languages emphasize high-level , visualization, and multi-view representations to support and verification rather than direct computation. This distinction allows modeling languages to operate at the problem domain level, focusing on entities, relationships, and behaviors, whereas programming languages address the solution space with constructs like variables and control flows. Modeling notations may be graphical or textual, but their primary goal remains conceptual clarity over operational efficiency. Within , modeling languages play a pivotal role by enabling the systematic creation of platform-independent models, their subsequent for consistency and completeness, and automated transformations into or other artifacts, thereby streamlining development and reducing errors. This approach shifts the focus from manual coding to model-centric processes, where languages provide the foundational infrastructure for , validation, and generation.

Historical Development

The roots of modeling languages trace back to the mid-20th century, with early contributions from aimed at visualizing and formalizing system behaviors. In 1962, Carl Adam Petri introduced Petri nets as a mathematical modeling tool for describing distributed systems and concurrent processes, laying foundational concepts for concurrency and in later languages. Flowcharting, which emerged in the 1920s for industrial process analysis, was adapted for in the 1940s and 1950s to represent algorithmic steps and decision flows in early computing projects, such as those at the Institute for Advanced Study. By the 1970s, methods advanced these ideas; for instance, Nassi-Shneiderman diagrams, developed in 1973, provided a hierarchical, box-based notation to enforce principles without arrows, influencing practices. Influences from and further shaped modeling languages during this period. Algebraic specifications, pioneered in the 1970s by the Algebraic Data Type (ADJ) group including A. Goguen and others, offered a formal approach to defining data types and operations through equations, impacting specification languages in and abstract modeling. Engineering disciplines contributed through tools like state transition diagrams and entity-relationship models, which emphasized system decomposition and data flows, bridging to object-oriented paradigms in the 1980s. The 1990s marked a pivotal unification effort, culminating in the (UML). Developed between 1994 and 1995 by , , and James Rumbaugh at , UML integrated diverse notations into a standardized for ; it was adopted as a standard by the (OMG) in 1997. This standardization resolved fragmentation from earlier methods like Booch and OMT, enabling widespread use in . Building on UML, the (SysML) emerged in 2006 under OMG auspices, extending UML for with profiles for requirements, architecture, and parametric modeling to address interdisciplinary needs. Domain-specific advancements continued into the 2010s, with the release of (BPMN) version 2.0 in January 2011 by OMG, which formalized through enhanced semantics and XML interchange, succeeding BPMN 1.0 from 2006. Recent developments as of 2025 have integrated modeling languages with AI-driven tools, such as automated diagram generation and semantic enhancement using large language models, improving model creation efficiency in complex systems. Concurrently, OMG has advanced standards for digital twins through initiatives like the AI Joint Working Group for integration with and related technologies, alongside modeling extensions such as Microsoft's Digital Twins Definition Language (DTDL) to support and real-time across industries. In July 2025, the EDM Council acquired OMG, enhancing collaboration on standards for digital twins and information-centric operations.

Classification

By Notation Style

Modeling languages can be classified by their notation style, which refers to the primary mode of expression used to represent models—graphical, textual, or hybrid. This classification emphasizes how the syntax and semantics are conveyed to users, influencing , tool integration, and applicability in different contexts. Graphical notations leverage visual elements like diagrams, while textual ones employ written symbols akin to , and hybrid approaches integrate both for flexibility. Graphical modeling languages utilize visual diagrams, such as boxes, arrows, and icons, to represent system structures and behaviors. These notations enhance intuitiveness by mimicking human spatial reasoning, facilitating easier comprehension and communication among diverse stakeholders, including non-technical users. For instance, the (UML) employs graphical diagrams like class diagrams to visualize object-oriented designs, promoting abstraction while maintaining rigorous syntax and semantics. The advantages include improved overview of complex relationships at a glance, though they may require specialized tools for editing and can become cluttered in large-scale models. Textual modeling languages rely on written symbols or code-like syntax to define models, often resembling lightweight programming constructs. This style offers benefits in precision, as it allows unambiguous specification of details through formal expressions, and supports automation via parsing and analysis tools. A prominent example is Alloy, a relational logic-based language for formal specification, which uses textual declarations to model structural constraints and enables automated verification through SAT solvers. Textual notations excel in capturing intricate logic without visual ambiguity but may demand greater familiarity with syntax, potentially hindering accessibility for visual learners. Hybrid modeling languages combine graphical and textual elements, allowing users to switch between or synchronize notations, such as through diagram-to-text or bidirectional . This approach mitigates limitations of single styles by enabling intuitive visualization alongside precise textual manipulation, though it introduces trade-offs like increased in tool support and steeper learning curves for integrated environments. For example, frameworks like Sirius embed textual domain-specific languages within graphical editors to support seamless transitions. Comparing notation styles reveals distinct pros and cons: graphical languages provide high-level overviews ideal for initial design and stakeholder discussions, while textual ones afford detailed, machine-processable specifications suited for verification and implementation. Hybrid styles balance these by offering versatility but often require robust metamodels to define consistent notations across modes; metamodels, such as those in UML's , specify abstract and concrete representations to ensure . The shift toward graphical dominance in the , driven by standards like UML, underscored their role in visual modeling, yet textual and hybrid approaches have gained traction for precision in .

By Scope and Specificity

Modeling languages are classified by their scope and specificity to reflect the breadth of their applicability and the degree to which they are customized for particular contexts, influencing their , expressiveness, and integration potential. This underscores a : broader scopes enable versatility across diverse problems, while narrower specificity allows for more precise and efficient modeling within targeted areas. Such categorization aids in selecting languages that align with requirements, balancing generality with domain expertise. General-purpose modeling languages possess a wide scope, applicable to numerous domains without restriction to a single industry or field, thereby supporting the modeling of varied systems such as software architectures or processes. For example, the (UML) facilitates the representation of object-oriented systems across , , and beyond, promoting that enhances communication among stakeholders. This broad applicability fosters reusability and but often necessitates additional profiles or extensions to handle highly specialized requirements effectively. Domain-specific modeling languages (DSMLs) exhibit narrower scope, customized for particular industries or application areas, such as finance for or healthcare for patient flow optimization. By embedding domain-specific concepts and rules into their syntax and semantics, DSMLs improve modeling efficiency, reduce gaps, and boost through higher expressiveness tailored to expert users. However, their specificity introduces risks, including reduced with general-purpose tools and challenges in integrating models across domains, potentially complicating system-wide analyses. Discipline-specific modeling languages target focused subfields, emphasizing particular methodologies or representational paradigms within a broader domain. Behavioral discipline languages, such as those employing state machines, capture dynamic system evolutions and transitions, aligning with frameworks in . Algebraic discipline languages, conversely, rely on equation-based formulations to model mathematical relationships and constraints, supporting declarative descriptions in optimization and contexts. These languages often integrate tightly with discipline methodologies, enhancing precision for specialized analyses like protocol synthesis or . Knowledge and information modeling languages specialize in representing data structures, semantics, and relationships, with subtypes differentiated by their focus on structural versus inferential aspects. Data-oriented subtypes, like Entity-Relationship (ER) diagrams, emphasize relational schemas for database design, enabling clear depiction of entities, attributes, and associations. Ontology-oriented subtypes, such as the Web Ontology Language (OWL), extend this to formal knowledge representation, supporting reasoning and inference over conceptual hierarchies. This distinction allows for targeted modeling of information flows in data-intensive systems while accommodating . Emerging scopes in modeling languages have expanded post-2020 to address (VR), 3D simulations, and environments, where specificity targets immersive and spatial interactions. These languages enable the definition of dynamic 3D scenes, user avatars, and real-time behaviors in , often leveraging standards for VR/AR integration to support collaborative simulations. For example, the Extensible 3D (X3D) standard defines notations for 3D virtual world visualization, while Humanoid Animation (HAnim) supports avatar modeling. Developments in this area prioritize scalability for platforms, facilitating complex modeling of persistent digital ecosystems with enhanced realism and interactivity, as part of ongoing ISO/IEC JTC 1 efforts as of 2023.

Key Examples

General-Purpose Languages

The (UML) is a prominent general-purpose modeling language standardized by the (OMG) for specifying, visualizing, constructing, and documenting software-intensive systems. It supports a wide range of diagrams divided into structural and behavioral categories, enabling broad applicability across projects without domain-specific tailoring. Structural diagrams include class diagrams for representing static relationships among classes, object diagrams for instance-level views, component diagrams for modular , and deployment diagrams for hardware-software mappings. Behavioral diagrams encompass diagrams for functional requirements, activity diagrams for modeling, state machine diagrams for dynamic behaviors, and sequence diagrams for interaction timelines. UML's evolution began with version 1.0 in 1997, progressing through major releases like UML 1.5 in 2003 and UML 2.0 in 2005, with the current standard at version 2.5 adopted in 2015 and refined to 2.5.1 in 2017. Its metamodel is defined using the Meta-Object Facility (MOF), OMG's standard for metadata and model representation, which ensures semantic consistency and . The (BPMN), another key general-purpose language standardized by OMG, focuses on modeling business workflows and processes in a graphical, intuitive manner suitable for stakeholders across industries. Core elements include events to denote process triggers or milestones—such as start events for initiation, intermediate events for interruptions, and end events for termination—along with gateways for controlling flow divergence and convergence, like exclusive gateways for decisions or parallel gateways for concurrent paths. BPMN also incorporates tasks for activities, sequence flows for directing process progression, and pools/lanes for organizational roles, facilitating executable process representations. Adopted in version 2.0 in 2011 and updated to 2.0.2 in 2013, BPMN promotes standardization in process documentation and automation without restricting to specific sectors. Complementing UML, the (OCL) serves as a formal, declarative for specifying constraints on UML models, enhancing precision in general-purpose modeling. OCL enables the definition of invariants to maintain model consistency, preconditions and postconditions for operations, and queries for model navigation, all expressed in a textual, machine-readable syntax integrated with UML diagrams. Standardized by OMG since version 1.5 in 2002, with the latest at version 2.4 in 2014, OCL aligns closely with UML's metamodel to avoid ambiguity in behavioral and structural specifications. The Entity-Relationship (ER) model represents a foundational general-purpose approach to , introduced by Peter Chen in 1976 for conceptual applicable to diverse information systems. ER diagrams depict entities as rectangles, relationships as diamonds connecting entities, and attributes as ovals, providing a high-level of data structures without implementation details. This notation supports constraints and keys, making it versatile for initial modeling stages in software and database projects. General-purpose modeling languages like UML and BPMN offer strengths in reusability, as their standardized notations reduce training costs and enable artifact sharing across projects and organizations. Extensive tool ecosystems further amplify this, with open-source options such as providing comprehensive UML support, including diagram editing, validation, and code generation within the Eclipse IDE.

Domain-Specific Languages

Domain-specific languages (DSLs) in modeling are tailored notations and semantics designed to address the unique requirements of particular industries or problem domains, enhancing expressiveness and efficiency by focusing on domain-relevant abstractions while minimizing extraneous features of general-purpose languages. These languages often extend existing standards or are built from scratch to capture domain-specific concepts, such as in or biochemical reactions in , thereby reducing modeling complexity and improving tool within specialized workflows. In software and systems engineering, SysML v2.0 (Systems Modeling Language), adopted by the (OMG) in July 2025, serves as a prominent DSL for (MBSE). It uses a new metamodel based on the Kernel Modeling Language (KerML), independent of UML, to provide precise textual modeling of complex systems, including requirements, structure, behavior, and parametrics. SysML v2 supports standardized views (e.g., general, , action flow) and an () for enhanced tool and automation in domains like and automotive. Similarly, , developed by , is a graphical DSL for modeling and simulating multidomain dynamical systems, particularly control systems, using block diagrams to represent signal flows, feedback loops, and physical components without requiring textual code. Its domain-specific blocks for continuous-time dynamics and enable rapid prototyping and verification in applications like and automotive control. For business and finance domains, provides a standardized DSL for modeling, defining layered viewpoints across , application, and domains to visualize relationships and support in organizational transformations. Maintained by The Open Group, it uses core elements like services, processes, and artifacts to create unambiguous models that align IT with , with version 3.2 (released 2022) emphasizing motivation and implementation aspects. In , DSLs such as MathOCL target derivative instruments and , allowing declarative specification of contracts, valuations, and simulations in a syntax optimized for quantitative , thereby streamlining compliance and scenario analysis. Another example is the generic DSL for proposed in research, which automates including valuation, scheduling, and document generation through domain-specific primitives for options and swaps. In scientific domains, Modelica is an equation-based, object-oriented DSL for modeling and simulating complex physical systems across multi-domains like , , and , enabling acausal connections of reusable components defined by differential-algebraic equations. Its non-causal modeling paradigm allows users to describe systems declaratively without specifying computational order, facilitating simulation of cyber-physical systems in tools like or . For biology, the Systems Biology Markup Language (SBML) is an XML-based DSL for representing computational models of biochemical networks, including reactions, species, and parameters, to promote data exchange and reproducibility in research. Level 3 of SBML supports extensions for spatial, qualitative, and multi-component models, with widespread adoption in software like COPASI for analyzing gene regulatory and metabolic pathways. Customization of DSLs typically involves lightweight extensions via profile mechanisms, such as UML profiles defined by the (OMG), which add domain-specific stereotypes, tagged values, and constraints to UML metaclasses without altering the core language. For more extensive tailoring, tools like Xtext enable the creation of full textual DSLs by generating parsers, editors, and validators from definitions, supporting iterative development of languages with IDE features like and autocompletion. Post-2020 trends in AI and have spurred DSLs for modeling architectures, integrating with AI workflows to specify topologies, training pipelines, and deployment constraints, as seen in approaches bridging MDE and AI systems . These evolutions emphasize automation and scalability, often leveraging generative techniques to derive executable models from high-level specifications.

Applications

In Software and Systems Engineering

In software and , modeling languages play a pivotal role in by enabling the visualization and specification of stakeholder needs through diagrams such as models. diagrams, part of the (UML), graphically depict interactions between actors (e.g., users or external systems) and the system under development, helping to identify functional requirements and scenarios early in the process. This approach facilitates structured documentation of requirements, reducing ambiguity and supporting iterative refinement during elicitation phases. During design and architecture phases, modeling languages support structural modeling to define component interactions, such as class diagrams and sequence diagrams in UML, which outline relationships, behaviors, and data flows among system elements. A key application is model-to-code generation within (MDA), an (OMG) standard that automates the transformation of platform-independent models into executable code for specific technologies. MDA emphasizes separating from implementation details, enabling reuse and portability across middleware platforms like or .NET. For , modeling languages integrate with and formal analysis techniques to ensure system correctness. allows dynamic execution of behavioral models to test scenarios, while like verify properties such as deadlock freedom or liveness. The SPIN tool, an open-source model checker, integrates with modeling languages by translating system models (e.g., in Promela) into verifiable automata, enabling exhaustive state-space exploration for concurrent software. This integration has been applied in verifying distributed systems, identifying errors that traditional testing might miss. In the 2020s, modeling languages have increasingly supported practices by enabling declarative representations of and workflows within continuous integration/continuous delivery () pipelines. Tools like Terraform function as declarative modeling languages, allowing engineers to define cloud (e.g., using Configuration Language) that can be version-controlled, tested, and automatically provisioned. This approach integrates with CI/CD tools like AWS CodePipeline, facilitating automated validation, plan generation, and deployment of changes, thus enhancing and reducing manual errors in cloud-native environments. Case studies illustrate these applications effectively. In agile software projects, UML has been used to bridge user stories with detailed designs; for instance, a study on automatic transformation of user stories into UML use case diagrams using NLP techniques achieved precision rates of 87% to 98%. For systems engineering in aerospace, NASA's adoption of Systems Modeling Language (SysML) in Model-Based Systems Engineering (MBSE) for the Orion spacecraft involved creating digital twins of subsystems, enabling simulation-driven verification that aligned models with as-built hardware and mitigated integration risks during Artemis I preparations. Similarly, a NASA aeronautics project employed SysML to model multidisciplinary interactions, resulting in clearer requirements traceability and faster iteration cycles compared to document-based approaches. In 2025, the Object Management Group adopted SysML v2.0, enhancing MBSE applications with improved interoperability and formal semantics for complex systems projects.

In Other Disciplines

Modeling languages extend beyond into diverse fields, enabling precise representation and of complex systems in , , and . In modeling, the (BPMN) serves as a standardized graphical for depicting workflows, facilitating process optimization by identifying inefficiencies and streamlining operations across organizations. BPMN diagrams support by mapping activities from input to output, allowing stakeholders to evaluate cost structures and competitive advantages in supply chains. In scientific simulations, Petri nets provide a mathematical modeling language for representing dynamic workflows, particularly in , where they simulate concurrent processes such as gene regulatory networks and metabolic pathways to predict system behaviors under varying conditions. Similarly, agent-based modeling languages capture interactions among autonomous entities to study emergent phenomena in social sciences, such as opinion dynamics or spread within populations, offering insights into behaviors without relying on aggregate assumptions. Engineering domains leverage specialized modeling languages for hardware and . VHDL (VHSIC ) is a for describing digital circuits at various abstraction levels, enabling , synthesis, and verification of integrated circuits in . In mechanical engineering, finite element modeling languages, such as the Finite Element Modeling (femML), standardize the exchange of mesh data and boundary conditions, supporting simulations of stress, , and effects in complex structures. Emerging applications in 2025 highlight the role of modeling languages in advanced simulations. Digital twins in manufacturing utilize OPC UA (Open Platform Communications Unified Architecture) as a modeling framework to create real-time virtual replicas of physical assets, integrating sensor data for and process optimization on factory floors. Environmental modeling languages, including extensions of domain-specific ones like , drive climate simulations by formalizing equations for atmospheric dynamics and carbon cycles, aiding in scenario forecasting for policy decisions. These applications underscore interdisciplinary benefits, where modeling languages bridge communication gaps among experts; for instance, stock-flow models in represent balances between assets and transactions, allowing economists and policymakers to align fiscal analyses with environmental or social impact assessments.

Evaluation Frameworks

Quality Criteria

Quality criteria for modeling languages encompass a set of essential attributes that determine their effectiveness in representing complex systems, supporting analysis, and facilitating communication among stakeholders. These criteria ensure that a language not only captures intended meanings accurately but also aligns with user needs, domain requirements, and broader organizational contexts. Established frameworks, such as the SEQUAL quality framework, provide a structured basis for evaluating these attributes, emphasizing both intrinsic language properties and extrinsic factors like and adaptability. Core criteria include expressiveness, which refers to the language's capacity to model all relevant domain concepts without incompleteness or redundancy, enabling comprehensive representation of structural, behavioral, and other perspectives. Simplicity focuses on ease of use, achieved through intuitive notations that minimize , such as limiting the number of constructs and employing graphic economy to avoid unnecessary visual clutter. Formality involves precise and semantics, allowing for unambiguous interpretation, automated verification, and tool-based execution, which is crucial for rigorous in contexts. Extensibility permits customization and extension mechanisms, such as profiles or metamodel adaptations, to accommodate evolving requirements without compromising core integrity. Domain appropriateness assesses how well the language fits the problem space, including coverage of key concepts specific to the application area, often evaluated through ontological alignment to ensure completeness in representing domain entities and relationships. This criterion ensures the language supports essential perspectives, such as processes and resources in enterprise modeling, avoiding gaps that could lead to incomplete specifications. User-centered criteria prioritize human factors in modeling. Modeller appropriateness evaluates the language's support for knowledge externalization, considering the and aids like metaphors to help creators articulate ideas efficiently. Comprehensibility appropriateness measures for non-experts, incorporating principles like semantic transparency—where symbols visually evoke their meanings—and cognitive integration to group related elements intuitively. Participant (stakeholder) appropriateness ensures alignment with users' backgrounds, using familiar constructs to facilitate interpretation and across diverse roles. Organizational fit examines integration with existing tools, standards, and processes, including tool appropriateness for seamless and organizational appropriateness for adaptability to institutional goals and . This alignment enhances long-term viability by supporting standardized workflows and cross-tool compatibility. In contemporary contexts, has emerged as a vital criterion, particularly for handling large-scale models without performance degradation, through features like modular and efficient editing mechanisms in textual or hybrid notations.

Assessment Methods

Assessment of modeling languages involves structured frameworks that adapt established quality standards to evaluate aspects such as adaptability and usability, alongside practical methods and tools tailored to their unique characteristics. The ISO/IEC 25010 standard, which defines a product quality model with characteristics including functional suitability, performance efficiency, compatibility, usability, reliability, security, maintainability, and portability, has been adapted for evaluating modeling languages and their supporting tools. Similarly, the (OMG) provides evaluation guidelines through its standards, such as those in the (SysML), which emphasize criteria like correctness, precision, conciseness, and consistency for assessing model quality in . The Multiple Modelling language Quality Evaluation Framework (MMQEF) enables systematic comparison of languages like UML and BPMN by analyzing their syntactic, semantic, and pragmatic elements against predefined quality attributes. Empirical methods, such as user experiments, are widely used to gauge the effectiveness and satisfaction of modeling languages in practical scenarios. In these studies, participants perform modeling tasks, with metrics like task completion time and error rates measuring usability and expressiveness; for example, controlled experiments comparing languages like BPMN and EPC revealed differences in user comprehension and productivity. Formal metrics provide quantitative insights into structural properties, including adaptations of cyclomatic complexity for diagrams, which counts linearly independent paths in control flow representations to assess diagram maintainability and testability. In UML class diagrams, for instance, cyclomatic-like measures evaluate attribute and method interconnections to identify overly complex designs that hinder readability. Case-based analysis complements these by applying languages to real-world scenarios, such as enterprise modeling, to evaluate expressiveness and applicability through qualitative review of outcomes like model completeness and stakeholder alignment. Tool-based assessments enhance objectivity by automating validation and interoperability checks. The Object Constraint Language (OCL) checkers, integrated into environments like the USE tool, validate model consistency by executing constraints against UML diagrams, detecting violations such as invalid associations or state inconsistencies during model animation. Interoperability testing tools, often model-based, simulate interactions between languages or tools to verify data exchange fidelity, as seen in TTCN-3 scripts for standards compliance in distributed systems modeling. Automated model smell detectors, such as EMF Smell in Eclipse IDEs, identify anti-patterns like overly large classes or redundant associations in UML models using rule-based or metric-driven heuristics, addressing gaps in manual inspection. Recent evaluations highlight challenges, including biases in empirical methods where participant demographics may skew results toward certain user groups, prompting a 2020s emphasis on inclusivity through diverse cohorts to ensure equitable design. Trade-offs between quantitative metrics, which offer scalability but overlook contextual nuances, and qualitative approaches, which provide depth at higher cost, remain a key concern, influencing hybrid evaluation strategies in contemporary frameworks.

References

  1. https://www.omg.org/spec/UML
  2. https://cacm.acm.org/research/development-use-cases-for-semantics-driven-modeling-languages/
  3. https://www.sei.cmu.edu/blog/modeling-languages-for-model-based-systems-engineering-mbse/
  4. https://www.sei.cmu.edu/blog/software-modeling-what-to-model-and-why/
  5. https://www.omg.org/spec/UML/About-UML/
  6. https://www.rose-hulman.edu/class/cs/csse490-mbse/Readings/DSL-Survey-WhenHow.pdf
  7. https://pmc.ncbi.nlm.nih.gov/articles/PMC5658286/
  8. https://sebokwiki.org/wiki/Modeling_Standards
  9. https://www.se-rwth.de/staff/rumpe/publications/Modeling-Languages-Syntax-Semantics-and-All-That-Stuff.pdf
  10. https://www.sciencedirect.com/science/article/pii/S1477842415000408
  11. https://www.sciencedirect.com/topics/computer-science/modeling-language
  12. http://yusun.io/papers/dspd-dslcat-2008.pdf
  13. http://www.scholarpedia.org/article/Petri_net
  14. https://homes.luddy.indiana.edu/nensmeng/files/Ensmenger2016-draft.pdf
  15. https://www.researchgate.net/publication/220673238_Algebraic_specifications_Some_old_history_and_new_thoughts
  16. https://sourcemaking.com/uml/basic-principles-and-background/history-of-uml-methods-and-notations
  17. https://sysml.org/sysml-faq/
  18. https://www.omg.org/spec/BPMN/2.0/About-BPMN
  19. https://www.sciencedirect.com/science/article/pii/S1877050925028613
  20. https://www.omg.org/news/releases/pr2024/10-31-24.htm
  21. https://www.omgwiki.org/wp-test/an-introduction-to-the-next-generation-of-digital-twins/
  22. https://www.digitaltwinconsortium.org/press-room/07-01-25/
  23. https://doi.org/10.3390/math11051263
  24. https://people.computing.clemson.edu/~johnmc/courses/Publish/openup/guidances/concepts/visual_modeling_2C089766.html
  25. https://sceweb.uhcl.edu/helm/ROLE-ProjectManager/myfiles/IBMRUP/manuals/intro/im_bp4.htm
  26. https://people.csail.mit.edu/dnj/publications/alloy.pdf
  27. https://sdq.kastel.kit.edu/publications/pdfs/seifermann2016a.pdf
  28. https://gemoc.org/pub/20190625-MLE19/paper3.pdf
  29. https://www.omg.org/cgi-bin/doc?formal/01-09-72.pdf
  30. https://www.rose-hulman.edu/class/cs/csse490-mbse/SlidePDFs/session14.pdf
  31. https://www.researchgate.net/publication/359150925_The_Purpose-Specificity_Framework_for_Domain-Specific_Conceptual_Modeling
  32. https://ceur-ws.org/Vol-3514/paper85.pdf
  33. https://homepages.cwi.nl/~paulk/publications/Sigplan00.pdf
  34. https://www.mdpi.com/2076-3417/12/23/12286
  35. https://link.springer.com/article/10.1007/s10703-006-7845-7
  36. https://www.researchgate.net/publication/266859114_Algebraic_Modeling_Languages_Introduction_and_Overview
  37. https://jtc1info.org/jtc-1-standards-and-standardization-for-the-metaverse/
  38. https://www.omg.org/spec/UML/2.5.1/About-UML
  39. https://www.omg.org/spec/UML/2.5.1/PDF
  40. https://www.omg.org/spec/MOF/2.5.1/PDF
  41. https://www.omg.org/spec/BPMN/2.0.2/About-BPMN
  42. https://www.omg.org/spec/BPMN/2.0.2/PDF
  43. https://www.omg.org/spec/OCL/2.4/About-OCL
  44. https://www.omg.org/spec/OCL/2.4/PDF
  45. https://dl.acm.org/doi/10.1145/320434.320440
  46. https://eclipse.dev/papyrus/
  47. https://www.omg.org/spec/category/uml-profile/About-uml-profile
  48. https://link.springer.com/article/10.1007/s10270-024-01211-y
  49. https://www.omg.org/spec/SysML/2.0/About-SysML
  50. https://www.omg.org/news/releases/pr2025/07-21-25.htm
  51. https://www.mathworks.com/products/simulink.html
  52. https://www.mathworks.com/solutions/control-systems.html
  53. https://www.opengroup.org/archimate-forum/archimate-overview
  54. https://www.opengroup.org/sites/default/files/docs/downloads/n190p_5.pdf
  55. https://www.opengroup.org/archimate-licensed-downloads
  56. https://ceur-ws.org/Vol-3620/agilemde23_paper03.pdf
  57. https://rucore.libraries.rutgers.edu/rutgers-lib/23837/PDF/1/
  58. https://modelica.org/
  59. https://modelica.org/documents/MLS.pdf
  60. https://sbml.org/
  61. https://sbml.org/documents/specifications/
  62. https://eclipse.dev/Xtext/
  63. https://dl.acm.org/doi/10.1145/2430536.2430539
  64. https://dl.acm.org/doi/abs/10.1007/s00766-004-0203-7
  65. https://www.omg.org/mda/mda_files/developing_in_omg.htm
  66. https://www.eecg.toronto.edu/~jacobsen/courses/ece1770/reader/developing-in-mda.pdf
  67. https://spinroot.com/
  68. https://ieeexplore.ieee.org/document/9750494/
  69. https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/create-a-ci-cd-pipeline-to-validate-terraform-configurations-by-using-aws-codepipeline.html
  70. https://www.sciencedirect.com/science/article/pii/S1877050918303600
  71. https://ntrs.nasa.gov/api/citations/20220017217/downloads/Orion%2520Digital%2520Twin%2520v9.pdf
  72. https://arc.aiaa.org/doi/10.2514/6.2018-3361
  73. https://www.omg.org/bpmn/
  74. https://www.ibm.com/think/topics/bpmn
  75. https://pmc.ncbi.nlm.nih.gov/articles/PMC551550/
  76. https://link.springer.com/article/10.1007/s11573-021-01070-9
  77. https://resources.pcb.cadence.com/blog/2020-hardware-description-languages-vhdl-vs-verilog-and-their-functional-uses
  78. https://asmedigitalcollection.asme.org/IDETC-CIE/proceedings/IDETC-CIE2002/36215/187/292771
  79. https://opcconnect.opcfoundation.org/2024/09/leveraging-opc-ua-for-digital-twin-realization/
  80. https://www.researchgate.net/publication/227494365_The_value_of_environmental_modeling_languages_for_building_distributed_hydrological_models
  81. https://www.levyinstitute.org/publications/stock-flow-consistent-macroeconomic-models-a-survey
  82. https://www.researchgate.net/publication/302310382_Quality_of_Modelling_Languages
  83. https://dl.acm.org/doi/10.1145/1810295.1810442
  84. https://link.springer.com/chapter/10.1007/11557432_51
  85. https://ceur-ws.org/Vol-1076/paper3.pdf
  86. https://www.sciencedirect.com/science/article/abs/pii/S0306437916302071
  87. https://www.researchgate.net/publication/287455117_Usability_evaluation_of_modeling_languages_An_empirical_research_study
  88. https://www.richard-seidl.com/en/blog/uml-metrics
  89. https://www.researchgate.net/figure/Class-complexities-of-the-UML-example_tbl4_346519682
  90. https://link.springer.com/chapter/10.1007/978-3-319-12206-9_21
  91. https://ieeexplore.ieee.org/document/8904872/
  92. https://dl.acm.org/doi/10.1145/1345169.1345173
  93. https://www.uni-marburg.de/de/fb12/arbeitsgruppen/swt/publikationen/dateien/2010/abt10.pdf
Add your contribution
Related Hubs
User Avatar
No comments yet.