In this work we are evaluating the use of the Java programming language as an environment for the specification and description of the behavior of systems. By systems, we mean combinations of hardware and software that interface to the real world (hence the real-time requirement). In this project, we use Java as a platform for embedding formal models of computation as restrictions on the Java syntax and as packages (object libraries) that extend the functionality by forming "embedded" languages.
We believe Java is a good choice for this work for many reasons, for example because of its built-in, low-level concurrency in the form of threads, and its explicit memory model. We use the concurrency as a mechanism for specifying partial orders on the computation, and we take advantage of the memory model by using it to optimize memory and communication management. Java also allows us to combine classes via an external, explicit representation of the interfaces between different models of computation and so implement heterogeneous combinations of different forms of modeling (targets for implementation). This is particularly important for combining hardware and software models, or when the dynamic range in the level of detail in the description (e.g., from behavior to logic gates or even analog) is very large.
We are building a unified environment that allows for the migration, through successive refinement with human intervention, from one computational model to another, or from a very rough behavioral description that doesn't conform to any model into one that does, as needed. In order to make human intervention possible the environment needs to support different concurrent views of the behavior in order for the user to quickly evaluate effects of transformations on the functional behavior. The first target model of computation we are developing we call Abstractable Synchronous Reactive (ASR).
This methodology will raise the level of detail viewed by the designer, where the design process becomes that of specifying high-level behavior as well as external constraint that should be met in the implementation. It is the environment's job to make the required refinements, guided by the designer's intuition, into the design, to meet these high-level constraints while still maintaining the specified behavior.