Modern embedded computing systems tend to be heterogeneous in the sense of being composed of subsystems with very different characteristics, which communicate and interact in a variety of ways---synchronous or asynchronous, buffered or unbuffered, etc. Obviously, when designing such systems, a modeling language needs to reflect this heterogeneity. Today's modeling environments usually offer a variant of what we call amorphous heterogeneity to address this problem. This paper argues that modeling systems in this manner leads to unexpected and hard-to-analyze interactions between the communication mechanisms and proposes a more structured approach to heterogeneity, called hierarchical heterogeneity to solve this problem. It proposes a model structure and semantic framework that support this form of heterogeneity, and discusses the issues arising from heterogeneous component interaction and the desire for component reuse. It introduces the notion of domain polymorphism as a way to address these issues.

For many problem domains domain-specific languages (DSLs) offer users more appropriate notations and abstractions in which to model systems when compared with general purpose programming languages. These benefits can often be amplified if a visual notation is used instead of textual notations. In many problem domains visual notations are preferred by practitioners as they often are the most intuitive representation of a problem. However, the lack of supporting infrastructure for constructing, implementing, and maintaining visual languages in general and domain-specific visual languages (DSVLs) in particular has been an impediment to gaining wider acceptance. This paper describes techniques used in the Moses tool-suite for defining the syntax and semantics of DSVLs, which are very general, yet are built on a few very simple concepts and are therefore easy to apply.

In this paper UML statechart diagrams are used as an example of a generic approach to integrating a visual language in a heterogeneous modelling and simulation environment. A system represented in a visual language is syntactically defined as an attributed graph, with well-formedness rules specified by a set of first-order predicates over the abstract syntax of the graph. The language semantics are specified by an Abstract State Machine (ASM) parameterized with syntactically-correct attributed graphs. In this paper the key issues in the definition of UML statechart semantics are highlighted.

Higher-order Petri nets are a class of high-level Petri nets, in which Petri nets themselves are first-class objects. Here tokens may represent Petri nets and Petri nets may be the values of parameters and variables, as well as the result of computations performed during the occurrence of transitions. These features facilitate a number of very powerful higher-order modelling techniques, making Petri nets much more flexible, compositional, and the resulting models more reusable. This work explores the usefulness of some of these techniques by looking at them from an application point of view and by illustrating them with small to medium-sized application examples.

Complex control systems are heterogeneous, in the sense of discrete computer-based controllers interacting with continuous physical plants, regular data sampling interleaving with irregular communication and user interaction, and multilayer and multimode control laws. This heterogeneity imposes great challenges for control system design in terms of end-to-end control performance modeling and simulation, traceable refinements from algorithms to software/hardware implementation, and component reuse. This paper presents an actor-oriented design methodology that tackles these issues by separating the data-centric computational components (a.k.a. actors) and the controlflow-centric scheduling and activation mechanisms (a.k.a. frameworks). Semantically different frameworks are composed hierarchically to manage heterogeneous models and achieve actor and framework reuse. We introduce a notion of responsible frameworks to characterize the property that a framework can aggregate individual actor’s execution into a well-defined composite execution such that heterogeneous models can be composed. This methodology is implemented in the Ptolemy II software environment. We discuss how some of the most useful models for control system design are implemented as responsible frameworks. As an example, the methodology and the Ptolemy II software environment is applied to the design of a distributed, real-time software implementation of a pendulum inversion and stabilization system.

The SIM Application Toolkit is a standardized interface that provides mechanisms allowing applications, existing in the SIM, to interact and operate with any mobile equipment which supports the specific mechanisms required by the application. In case of Java Cards such software is implemented in Java. To simplify software development in this rather complex application domain, we developed a visual domain specific language. SIMtelligence Designer/J is used to create programs in that language and to translate them into Java. It is generated by the VL-Eli system, a tool for the implementation of visual languages.

1 Introduction In recent years, component-based development has emerged as a significant factor inthe production of large-scale software applications. By building systems from independently developed components, a promising means of achieving software reuse, rapiddevelopment and complexity management is provided.

Process networks are a popular modelling technique for distributed computing and signal processing applications. The ability to support various parallelism or communication patterns also makes them suitable for modelling multi-processor architectures. At the architecture description level, the language provides the flexibility to model actual processes using various formalisms. This is especially important when the systems are comprised of parts with distinct characteristics, e.g. control-based or dataflow-oriented. However, this heterogeneity of processes poses a challenge for the consistency analysis of process networks. This research proposes a lightweight method for analyzing the consistency of such networks. The method employs interface automata as a bridge between the architectural model and heterogeneous components representing concrete models of processes. Utilising interface automata, consistency is determined by a series of small tasks at both the architecture level and the component level. This separation of concerns simplifies the handling of heterogeneous components and alleviates the potential state space explosion problem when analyzing large systems.

models An important part of the design of complex systems is the evaluation of the large number of potential alternative designs. Due to the number and complexity of design parameters, this design space is potentially huge and very complex. Automating part of the design exploration task can be an invaluable help in finding the optimal or near optimal settings of design parameters. The choice of the most appropriate exploration strategy depends on the nature of the parameters, such as their role in the model, the dimensionality and structure of the design space including the number and location of local optima, etc. This paper advocates the use of higher-order modeling techniques to express exploration strategies. This allows users to formulate them in the same set of languages used to model the original system. Hence the set of design space exploration tools can be extended and parameterized as easily as the model itself. In this paper a higher-order modeling langage is presented. As an example a number of simple exploration tools are modeled and applied to a small optimization problem. 1

Modern environments for modeling and designing concurrent computational systems increasingly support heterogeneous system models, which are characterized by different coordination mechanisms governing the interaction between concurrent components in different parts or at different levels of the model. These interaction semantics, also called models of computation, pose a major challenge to the definition of the meaning of heterogeneous models, especially if such a definition is to be independent of any specific set of models of computation, ways of describing actors, or notations for describing models.