Model Intelligence Guides (MIGs)

An opensource project available from: http://www.eclipse.org/gmt/gems

Modeling scalability challenges for large systems. Model-driven engineering (MDE) is a promising form of system development that combines high-level visual abstractions that are specific to a domain with constraint checking and code-generation to simplify software development. As model-based tools and methodologies have evolved, however, it has become clear that in certain domains, such as distributed real-time and embedded (DRE) systems, the models are so large and the domain constraints so intricate that it is extremely hard for modelers to manually produce correct and high-quality models. In these domains, modeling tools that only provide solution-correctness checking via constraints provide few benefits over conventional hand-crafted development methods since the key complexity in these domains is their large model sizes and combinatorial constraints, not code construction per se. For example, specifying the deployment of software components to Electronic Control Units (ECUs), which are the automotive equivalent of a CPU, in a car, while observing configuration and resource constraints can easily generate solution spaces with millions or more possible deployments and few correct ones, even with only a few tens of model entities. For these large modeling problems, it is infeasible to create a complete and valid model manually.

Consider a group of 9 components that need to be deployed to one of 9 ECUs within a car. There are 9^9 = 387,420,489 unique deployments that could be tried. Part of the complexity, therefore, is how quickly the solution spaces grow as the number of model elements increases. A difficulty of highly combinatorial domains is that although modelers may satisfy domain constraints, their models may have poor quality, e.g., a modeler manually deploying components to nodes might use far more nodes than the minimum number required to host the set of components. Another difficulty is that modelers are lucky to find any valid solution with large models and complex constraints. Since finding a single solution is so hard, it becomes infeasible to produce scores of valid solutions and search for an optimal one. Although numerous numerical methods can search for a solution with a given percentage of optimality, they all rely on the ability to generate large numbers of valid solutions, which is not possible without automation.

In domains with large models and intricate constraints, modelers must be able to see hundreds of modeling moves into the future to satisfy global constraints or optimize costs. The more localized modeler decisions areand the less distant they peer into the futurethe less chance they can find a correct or good solution. One approach to creating solutions for problems in these domains is to transform partial solutions specified by modelers, such as listing the components and nodes they may be deployed to, into a format that can be solved using a general purpose solver, such as a constraint logic programming solver. There are many optimization, constraint solver, and inference engines available for this purpose. However, modeling is emerging as a major challenge since it is hard to automate the formulation of real problems in a suitable form for efficient algorithmic processing. Transforming an arbitrary graphical model into a format suitable for a general purpose solver is therefore tedious and error-prone. Likewise, integrating the results of the solver back into a modeling tool and providing interactive capabilities is also hard.

Solution approach -> Model Intelligence Guides address the challenges of modeling large and complex domains by:

  1. Providing constriant solver frameworks that respect domain-specific concepts from the modeling tool and provide a flexible mechanism for specifying solvers using domain notations. Modeling tool users are able to specify constraints in a notation that mirrors the domain and makes mapping requirements to the model easier.
  2. Mechanisms for guiding modelers towards solutions considered optimal (or sufficient) based on domain-specific quality metrics. MIGs iterate through multiple valid solutions and suggest those considered most optimal. Modelers can plug-in custom formulas to measure optimality in the domain and the GEMS presents suggestions based on various types of optimization.
  3. MIGs integration automates tedious and complex modeling tasks, such as solving for and assigning values for global constraints, performing repetitive localized decisions, or providing feedback to a modeler to suggest valid modeling decisions.
  4. MIGs accommodates long-running analyses for problem instances that cannot be solved on-line.
  5. When the constraint solver cannot find a solution, MIGs suggests ways to make the model tractable. In a domain requiring constraint solver assistance, manual approaches may not find the source of intractability in a model. It is therefore crucial that the constraint solver provide feedback to modelers.

With a constraint-solver integrated modeling environment, users go through an iterative process of specifying portions of a model, adding or refining existing domain constraints, debugging constraints that are not tractable, and using the constraint solver to automate model construction and optimization.

MIGs can guide the user in making localized decisions by highlighting optimal or valid model modifications and decrease user effort and modeling time. The solver framework can also be used to complete a batch process of model changes, such as connecting all components to a valid host, while respecting global constraints. Batch processes performed by MIGs arrive at higher quality solutions in less time than a manual approach. Finally, in situations when the users partial model (such as a listing of components and nodes they must be deployed to) cannot satisfy the domain constraints (e.g. the modeled nodes do not have sufficient resources to host the components) MIGs can suggest ways of bringing the model to a state that satisfies the domain constraints. For example, MIGs might indicate that a particular nodes available memory be increased to satisfy a failed resource requirement.


  1. Jules White, Andrey Nechypurenko, Egon Wuchner, and Douglas Schmidt, Reducing the Complexity of Designing and Optimizing Large-scale Systems by Integrating Constraint Solvers with Graphical Modeling Tools, Accepted book chapter proposal, Designing Software-Intensive Systems: Methods and Principles, a book edited by Dr. Pierre F. Tiako, Langston University, Oklahoma, USA
  2. Jules White, Douglas Schmidt, Aniruddha Gokhale, Simplifying Autonomic Enterprise Java Bean Applications via Model-driven Engineering and Simulation, Journal of Software and Systems Modeling, Springer
  3. Andrey Nechypurenko, Jules White, Egon Wuchner, and Douglas C. Schmidt, Applying Model Intelligence Frameworks for Deployment Problem in Real-time and Embedded Systems, Proceedings of MARTES: Modeling and Analysis of Real-Time and Embedded Systems to be held on October 2, 2006 in Genova, Italy in conjunction with the 9th International Conference on Model Driven Engineering Languages and Systems, MoDELS/UML 2006.

  4. Jules White, Andrey Nechypurenko, Egon Wuchner, and Douglas C. Schmidt, Intelligence Frameworks for Assisting Modelers in Combinatorically Challenging Domains, Proceedings of the Workshop on Generative Programming and Component Engineering for QoS Provisioning in Distributed Systems, October 23, 2006, Portland, Oregon.


Generic Eclipse Modeling System (GEMS)

An opensource project available from: http://www.sf.net/projects/gems

GEMS is a configurable toolkit for creating domain-specific modeling
and program synthesis environments for Eclipse. The configuration is accomplished through metamodels specifying the modeling paradigm (modeling language) of the application domain. The modeling paradigm contains all the syntactic, semantic, and presentation information regarding the domain; which concepts will be used to construct models, what relationships may exist among those concepts, how the concepts may be organized and viewed by the modeler, and rules governing the construction of models. The modeling paradigm defines the family of models that can be created using the resultant modeling environment.

The built-in metamodeling language is based on the UML class diagram notation. Metamodels in other E-core readable formats can be used as well. Metamodel constraints are specified in Java. Once a metamodel has been imported, an interpreter is run that traverses the model and generates an Eclipse plug-in for editing instances of the Domain Specific Modeling Language (DSML) described by the metamodel. The generated plug-in uses Eclipse's Graphical Editor Framework (GEF) and Draw2D plug-in to visualize the DSML as a diagram. Instances of the DSML may also have interpreters run on them to generate various artifacts or perform complex analyses.

GEMS is the frramework that we are building all of our other Eclipse
based modeling environments on. We are also planning to transition
several of our modeling tools built on GME to GEMS.

FireAnt, Model Driven Deployment of Enterprise Java Bean Applications

The effectiveness of deployment and configuration capabilities can be measured by three metrics: (1) the correctness of the deployment plan, i.e., whether or not the configuration and deployment of each component is accounted properly for, (2) the execution accuracy of the system, i.e., whether or not the plan is executed properly, and (3) the execution reproducibility, i.e., whether or not the plan can be executed repeatedly with the same results.  

FireAnt is a tool used to address the challenges of deploying and configuring EJB applications. FireAnt is a model-driven tool designed to improve deployment plan correctness by  (1) visually capturing the components that need to be deployed and their dependencies, (2) describing the target infrastructure required for the deployment, (3) visually specifying which components are to be deployed and configured on which machines, (4) visually specifying the configuration of the components on each target, and (5) providing constraint checking to ensure that each component and its dependencies are accounted for properly. The FireAnt deployer takes the deployment models produced by they modeling tool and does the run-time execution of the deployment plan to provide execution accuracy and reproducibility

Project Website:




Modeling Service Oriented Architectures (SOA)

To simplify the process of developing SOAs and ensuring their QoS
requirements are met, we are creating an eclipse plug-in for
model-driven development (MDD). The tool will focus on the choice and generation of J2EE-based service architectures that use the Apache Axis web services development kit. Expressive power in MDD is gained via notations and abstractions that are aligned more with the application domain, rather than low-level features of operating
systems, middleware platforms, and third-generation programming
languages. In particular, MDD uses visual representations to model
domain-specific abstractions, which enables designers of SOA's to
construct models that incorporate domain and QoS concepts as
first-class entities. Analysis can then be performed on the models to determine the appropriate service architecture and synthesize
implementations for both the internal and external service buses that can be configured, deployed, and integrated seamlessly with
applications written using J2EE. We have received an Eclipse
Innovation grant for this work.

We are also very interested in describing SOAs that integrate J2EE
systems and Corba systems. Raytheon is very interested in describing the communication between these systems, using a tool such as this, and then generating the bus between the systems using either either the Java Connector Architecture or SOAP.

Modeling SOAP Systems

We are working with Cisco to provide implementations of the BEEP
protocol(RFC3080, RFC3081). After creating implementations of BEEP over Java NIO and the Adaptive Communication Environment (ACE), we will implement SOAP over BEEP. Part of this work includes the development of a DSML for modeling SOAP applications. We plan to support specification of message composition, messaging style, and behavior for SOAP systems. The tool will then generate driver code and other implementation artifacts for building the modeled system.

The J3 Process

Project Website: http://www.sf.net/projects/j2eeml
Screenshots: http://sourceforge.net/project/screenshots.phpgroup_id=129443
Paper: http://www.cs.wustl.edu/~schmidt/PDF/J2EEML.pdf

the J3 Process, is an open-source MDD environment that supports the rapid design and implementation of autonomic applications. J3 consists of several MDD tools and autonomic computing frameworks, including (1) J2EEML, which captures the design of EJB applications, their quality of service (QoS) requirements, and the autonomic adaptation strategies of their EJBs via a domain-specific modeling language (DSML), (2) Jadapt, which is a J2EEML model interpreter that analyzes the QoS and autonomic properties of J2EEML models, and (3) JFense, which is an autonomic framework for monitoring, configuring, and resetting individual EJBs.

The J3 Process contains the following MDD tools and component
middleware frameworks that address the challenges of developing
autonomic EJB applications:

The J3 Process is currently built on top of GME but uses JET
templates. We plan to transition it to GEMS.