Model-based Computing
This is a very short overview of the motivation and characteristics of
model-based computing. More information can be found in the
descriptions of the individual projects, and in the publications.
Machine Software
A lot of software is developed for electro-mechanical machines,
such as software for design, control, scheduling, simulation,
diagnosis, productivity analysis, etc. Software like this has to
contain a lot of information about the machines, about its
components, particular configurations, normal and faulty behaviors,
interaction and timings issues, etc.
We believe that this machine information should not be baked into the
software, but should instead be prepared separately. Furthermore, we
believe that this information should come from declarative,
constraint-based models of the machines.
Machine Models
By model, we usually mean a description of the structure and
behavior of a device. The structure usually is its form,
layout, connections, etc. The behavior usually is the effect of
the device on something moving through it, or on the environment. For
example, a sheet inverter in a copier consists of rollers, gates and
sensors which are all somehow connected to each other or nearby
components; that's the structure. The inverter moves sheets and may
invert them; that's the behavior.
The type and detail of information contained in a model depends on the
application domain. For example, for scheduling you need to know how
sheets and images are handled, and what the timing properties are; for
advising a customer who is looking for specific capabilities, you need
the former, but not the latter. Nevertheless, carefully written
models, especially declarative models, can often be used for more than
one application. Multi-use is an important part of their
appeal.
A particularly hard part in developing machine software is analyzing
how machine components or operations interact. This analysis should
be done automatically. Therefore, we also stress the use of
compositional models, i.e., we start from models of simple
machine elements and then connect them to form larger models. Overall
behavior is derived automatically from behavior of the simpler
elements. Besides making modeling easier and less error-prone, this
also allows one to automatically and dynamically put together and
customize configurations (e.g., in a plug-and-play scenario).
Constraint-based Models
A natural way to express machine behavior is by explicitly writing
down the constraints that have to be satisfied for that
behavior. Constraints are essentially relationships between
quantities of interest involving variables. For example, if a sheet
takes 2s from the entry to the exit of a component, one might describe
this timing behavior with the constraint that time_in + 2 = time_out.
Using constraints in a particular application usually involves
solving the constraints, i.e., finding values for the variables.
For example, if you know time_out, you can compute time_in in the
above constraint. There are many well-known techniques for using
constraints over booleans, integers, reals, and finite domains. There
are also constraint programming languages which have constraints built
in.
Model-based software has three parts to it: machine-specific
models, task-specific but machine-independent architectures
and algorithms, and reasoning algorithms that link these
two by producing information from models in the right form for the
given task architecture. Depending on the application, the models may
be used directly or may be compiled in some way. Since the algorithms
are generic, they can be reused and reconfigured easily, another major
appeal of model-based software. For example, models for scheduling
may sometimes be compiled to finite-state machines (FSMs), and thus
the generic algorithm becomes a FSM interpreter. Where models are
used directly, the generic algorithms often contain constraint
solvers.
Our Interests
We are interested in all aspects of the development and use of
model-based software. We are developing modeling and
constraint languages, interpreters, compilers and reasoning algorithms
for these languages, constraint solving algorithms, domain-specific
modeling environments, and generic task algorithms and architectures.
Back to the model-based computing home page.
Last updated on October 13, 1995.