Rapide Tutorial

Table of Contents

Introduction

This tutorial draws heavily on existing documentation of the Rapide language and system.  It aims to provide a structured guide through it rather than replace it.

The links to the trails will be marked with for the language trail,  for the example trail,  for the Sw development trail and finally  for the syntax reference manual.

Language Trail

• Architecture Construction drescribes the concept of architecture and how Rapide approaches its description.
• Conventional programming elements: Types, Procedural Language. Rapide has as one of its subcomponents a conventional procedural language that can be used to  implement architecture modules.  This section is a description of this procedural language and the underlying type system that supports it.
• Event Model and posets: The central part of Rapide is the way it represents computations as Partially Ordered Sets of EvenTs. Understanding this section is crucial to understanding the computational model which is the foundation of Rapide.
• Structure of the process language: Events are generated by processes in Rapide, Processes are the unit of sequential execution and also the means of achieving parallelism.
• Reactive Statements: Rules. Rapide offers a rule based approach to describe behavior. Rules are pieces of code that execute when certain preconditions are matched. The execution of a rule may result in some events being generated, or due to the type structure of Rapide where modules, interfaces and connections are valid working types, rules may affect the connection topology of an architecture, making an architecture behave as a complete set of more "static" architectures.
• Patterns: The left hand side of rules are patterns to be matched. Given that the atomic execution component of a Rapide system is the event, patterns are defined over the set of events an architecture can generate.
• Advanced Topics: Rapide allows its own structural components like interfaces, connections and architectures themselves to be "first class" citizens of its type system. This means that architectures, modules and connections can be created and manipulated at runtime thus opening the door to expressing "families of behaviors" or "families of architectures".
• Generators: These are the factories where these structural elements can be created in a Rapide system.
• Usage of patterns in Architecture Descriptions: Patterns also allow very complex connection schemes to be described and expressed very succinctly.
• Maps and Constraints: Finally, Rapide allows some meta-information about architectures to be expressed as equivalence MAPS between architectures, that allow to asses whether two systems/architectures will behave in the same way, and therefore facilitates the description of "reference architectures" for a whole range of systems. Constraints in Rapide are asserted onto the topology of  events a particular system should produce, thereby allowing for "non-prescriptive" specifications of systems, but rather a requirements based specification of  them.

Example Trail

• Architectures, Actions and processes: Five dinning philosophers are used to illustrate the basic building blocks of Rapide and how they fit together in a specification that is executable.
• Connections and interfaces: A simple application/resource architecture is used to walk you through the construction of architectures using the Rapide tool set.
• Architecture Refinement: Rapide offers a variety of concepts to support system design at several levels of detail. This example shows how to define a subarchitecture that implements the resource interface declared in the previous example.
• Parametric Architectures and Pattern Matching: One of the most powerful features of Rapide is its ability to describe parametric architectures; architectures where the components and connections are determined at runtime from program parameters. In this example, the application/resource architecture is extended to handle an arbitrary number of resources that are specified by a parameter in the architecture.
• Constraints and Maps: Rapide offers the possibility of defining a "reference" system by the events it can and cannot generate, and then use this definition as a checkable constraint on other system architectures. This example shows how to use the Rapide tools to define a reference architecture, express constraints on that reference architecture, how to interpret another system as if it were an instance of the reference, and check it for conformance with the reference architecture.

Sw Engineering Trail

Syntax Reference Manual

• Architectures
• Interfaces
• Actions and functions
• Services
• Procedural Statements
• Reactive Statements
• General Reactive Rule Form
• Module Generator
• Constraints
• Maps