What does it mean to bootstrap a compiler, and why do it? This paper reports on the first bootstrapping of a full-scale EOO (Equation-based Object-Oriented) modeling language such as Modelica. Bootstrapping means that the compiler of a language can compile itself. However, the usual application area for the Modelica is modeling and simulation of complex physical systems. Fortunately it turns out that with some minor extensions, the Modelica language is well suited for the modeling of language semantics. We use the name MetaModelica for this slightly extended Modelica. This is a prerequisite for bootstrapping which requires that the language can be used to model and/or implement itself. The OpenModelica Compiler (OMC) has been written in this MetaModelica language. It originally supported only the standard Modelica language but has been gradually extended to also cover the MetaModelica language extensions. After substantial work, OMC is able to quickly compile itself and produces an executable with good performance. The benefits include a more extensible and maintainable compiler by introducing improved language constructs and a more powerful runtime that makes it easy to add functionality such as parser generators, debuggers, and profiling tools. Future work includes extracting and restructuring parts of OMC, making the compiler smaller and more modular and extensible. This will also make it easier to interface with OMC, making it possible to create more powerful and user-friendly OpenModelica-based tools. The compiler and its bootstrapping is a major effort -- it is currently about 330 000 lines of code, and the MetaModelica extensions are used routinely by approximately ten developers on a daily basis. 

The high abstraction level of equation-based object-oriented languages (EOO) such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present the first integrated debugger for equation-based languages like Modelica; which can combine static and dynamic methods for run-time debugging of equation-based Modelica models during simulations. This builds on and extends previous results from a transformational static equation debugger and a dynamic debugger for the algorithmic subset of Modelica.

The high abstraction level of equation-based object-oriented (EOO) languages such as Modelica has the drawback that programming and modeling errors are often hard to find. In this paper we present integrated static and dynamic debugging methods for Modelica models and a debugger prototype that addresses several of those problems. The goal is an integrated debugging framework that combines classical debugging techniques with special techniques for equation-based languages partly based on graph visualization and interaction. To our knowledge, this is the first Modelica debugger that supports both equation-based transformational and algorithmic code debugging in an integrated fashion.

Modelica models often contain functions with algorithmic code. The fraction of algorithmiccode is increasing in Modelica models since Modelica, in addition to equation-based modeling, is also used for embedded system control code and symbolic model transformations in compilers using the MetaModelica language extension. For these reasons, debugging of algorithmic Modelica code is becoming increasingly relevant.

Our earlier work in debuggers for the algorithmic subset of Modelica used trace-based techniques. These have the advantages of being very portable, but turned out to have too much overhead for very large applications.

The new debugger is the first Modelica debugger that can operate without trace information. Instead it communicates with a low-level C-language symbolic debugger, the Gnu debugger GDB, to directly extract information from a running executable, set and remove breakpoints, etc. This is made possible by the new bootstrapped OpenModelica compiler which keeps track of a detailed mapping from the high level Modelica code down to the generated C code compiled to machine code.

The debugger is operational, supports browsing of both standard Modelica data structures and tree/list data structures, and operates efficiently on large applications such as the OpenModelica compiler with more than 100 000 lines of code.

This paper describes the first open source Modelica graphic editor which is integrated with interactive electronic notebooks and online interactive simulation. The work is motivated by the need for easy-to-use graphic editing of Modelica models using OpenModelica, as well as needs in teaching where the student should be able to interactively modify and simulate models in an electronic book. Models can be both textual and graphical. The interactive online simulation makes the simulation respond in real-time to model changes, which is useful in a number of contexts including immediate feedback to students.

What does it mean to bootstrap a compiler, and why do it? This paper reports on the first bootstrapping (i.e., a compiler can compile itself) of a full-scale EOO (Equation-based Object-Oriented) modeling language such as Modelica. The Modelica language has been modeled/implemented in the OpenModelica compiler (OMC) using an extended version of Modelica called MetaModelica. OMC models the MetaModelica language and is now compiling itself with good performance. Benefits include a more extensible maintainable compiler, also making it easier to add functionality such as debugging support. This work is in line with the recently started Modelica 4 design effort which includes moving implementation of language features from the compiler to a Modelica Core library, allowing compilers to become smaller while increasing correctness and portability. A number of language constructs discussed for Modelica 4 are already supported in some form by the bootstrapped compiler. Future work includes adapting language constructs according to the Modelica 4 design effort and extracting and restructuring parts of the Modelica implementation from the OMC compiler to instead reside in a Modelica Core library, making the compiler smaller and more extensible.

In this paper we present an interactive course material called DrControl for teaching control theory concepts mixed together with exercises and example models in Modelica. The active electronic notebook, OMNotebook, is the basis for the course material. This can be an alternative or complement compared to the traditional teaching method with lecturing and reading textbooks. Experience shows that using such an electronic book will lead to more engagement from the students. OMNotebook can contain interactive technical computations and text, as well as graphics. Hence it is a suitable tool for teaching, experimentation, simulation, scripting, model documentation, storage, etc.

This report gives a language definition and tutorial on how to model languages using MetaModelica 1.0 – an extended subset of Modelica designed for efficient language modeling. Starting from an extremely simple language, a series of small languages are modeled by gradually adding features. Both interpretive and translational language semantics are modeled. Exercises with solutions are given.

The approach of allowing the modeling language to model language semantics in principle allows the definition of language semantics in libraries, which could be used to reverse the current trend of model compilers becoming very large and complex.

MetaModelica 1.0 is the first Modelica language version that supports  language modeling, and has been in extensive use since 2005, primarily in the development of the OpenModelica compiler.

MetaModelica 1.0 is strongly related to the RML specification language for Natural Semantics/Structural Operational Semantics, and is implemented using the RML compiler kernel but with a new compiler frontend. Thus, it lacks many standard language features in Modelica and requires a strictly functional modeling style.

The next version of MetaModelica, becoming available during the spring 2011, is implemented within the standard OpenModelica compiler. Therefore it also supports the standard Modelica 3 language features as well as additional features for expressiveness and conciseness.

In this paper we present a new functionality for graphical sketching in the OpenModelica interactive book, OMNotebook, which is part of the OpenModelica environment and used mainly for teaching. The new functionality is called OMSketch and allows the user to edit and draw shapes and figures within the electronic book. This allows teachers to prepare more pedagogic course material and stu-dents to make graphical notes in addition to the currenttextual ones.

The active electronic notebook, OMNotebook, is already used as basis for two course materials, DrModelica and DrControl for teaching the Modelica languages and control theory respectively. Electronic notebooks can be an alternative or complement compared to the traditional teaching me-thod with lecturing and reading textbooks. Experience shows that using such an electronic book will lead to more engagement from the students. OMNotebook can contain interactive technical computations and text, as well as graphics. Hence it is a suitable tool for teaching, experimentation, simu-lation, scripting, model documentation, storage, etc.

The paper presents a contribution to a Modelica benchmark suite. Basic ideas for a tool independent benchmark suite based on Python scripting along with models for testing the performance of Modelica compilers regarding large systems of equation are given. The automation of running the benchmark suite is demonstrated followed by a selection of benchmark results to determine the current limits of Modelica tools and how they scale for an increasing number of equations.