MERIDIAN and RAPIDware (and other SENS projects)

1
MERIDIAN and RAPIDware(and other SENS projects)

• Dr. Betty H.C. Cheng
• Software Engineering and Network Systems Lab
• Michigan State University
• www.cse.msu.edu/SENS
• www.cse.msu.edu/Meridian
• Project Investigators Cheng, Dillon, McKinley,
  Stirewalt, Kulkarni
• Project Sponsors
• Meridian National Science Foundation,
  EIA-0000433,
• RAPIDware Office of Naval Research

2
Overview

• Interactive distributed applications (IDAs).
• Goals and vision.
• Proposed research.
• Validation and contributions.

3
Interactive Distributed Applications
Interact with users processing/data distributed
across network.

• Examples
• On-board driver/pilot navigation systems.
• Computer-supported collaborative work
  environments.
• Distributed interactive simulation.

4
Characteristics of IDAs

• Interactivity
• Must interact with one or more human users.
• Design requires prototyping and experimentation.
• Concurrency
• Comprise levels of communicating, concurrent
  components.
• Analysis requires formal reasoning.
• Reuse
• IDAs built primarily from reusable components.
• E.g., comm. protocols, resource managers, data
  displays.
• Design involves selecting/specializing components.

5
Overview of talk

• Interactive distributed applications (IDAs).
• Goals and vision.
• Proposed research.
• Validation and contributions.

6
Research goals

• Improve quality of IDAs.
• Better IDAs (reliable, maintainable, extensible).
• Better development (faster, cheaper).
• Advance state of automated software-engineering
  (ASE) practice.
• Incorporate ASE techniques into mainstream
  development.
• Apply various formal methods in a new domain.
• Identify end-to-end automation techniques that
  take advantage of multiple phases of development.

7
Practical goals

• To have techniques adopted in practice
• Must complement existing design methods and
  notations.
• Otherwise, acceptance must overcome stiff
  economic hurdles.
• Implications
• Designers should not reformulate designs in a
  formal notation.
• Designers should not have to view the output of a
  formal analysis tool.
• We chose (UML) for representing IDA designs.

8
Meridian Vision
Design Processing
Specification Analysis
Testing/ Simulation
Model Editing
9
Enabling Technologies

• Formal representations throughout development
  process
• facilitates requirements analysis and
  traceability,
• enables reasoning about concurrency properties,
  and
• supports reuse.
• Visualization insulates designers from formal
  representations.
• Code generation/selection synthesizes systems
  from models.
• Simulation/prototyping tests non-functional
  requirements
• (e.g., usability, responsiveness, etc.)

10
Overview of talk

• Interactive distributed applications (IDAs).
• Goals and vision.
• Proposed research.
• Validation and contributions.

11
Model Editor

• Supports editing of UML models.
• Incorporates reusable IDA models.
• Generates formal representations of the models
• Supports automated analysis of graphical models
• Minerva graphical/viz utility
• Hydra generation of formal specifications

12
Tool suite (contd)

• Temporal Analyzer Augments UML models with
  temporal constraints.
• Graphical spec of timing constraints

13
Tool Suite (contd)

• Design Processor
• How to refine UML models to include design
  information.
• Incorporates architectural assumptions.
• Make use of IDA frameworks
• Including meta-frameworks
• Generates code and selects reusable components
• Adapts components to satisfy interface
  constraints
• Checks consistency between refinements

14
Reuse Environment

• Supports browsing/selection from reuse
  repositories.
• Component-based
• Index components by formal specs
• Search and retrieve based on specs

15
Tool Suite (contd)

• IDA Simulator
• Executes generated code over network simulator.

16
Research questions

• MERIDIAN vision opens the following research
  questions
• What is the proper formal representation(s) for
  IDAs?
• What class of formal analyses solves real
  IDA-development problems?
• How to create formal representations of informal
  (graphical) models?
• How to refine such representations with
  implementation details?
• How to validate the refinement?

17
Formal representations

• Hypothesis Behavioral view dominates IDA
  complexity.
• Formal representations support formal behavior
  analyses
• Labeled transition systems.
• Many notations LOTOS SDLGIL ...
• Analyses simulation, deadlock detection,
  fairness/liveness.
• Goal Identify formal analyses that solve IDA
  development problems and use this to guide
  representation choice.
• Initially, investigate LOTOS, Promela, and
  temporal logic.

18
Formalize graphical notations

• Formalize OO-modeling notation (UML).
• Extend prior work in formalizing OMT.
• Have multiple target languages
• LOTOS, VHDL, Promela, also exploring SMV and SDL
• Enable automated analysis of informal diagrams
• Extend formal timing-diagram notation (GIL).
• Propositional temporal logic inadequate for IDA
  properties.
• Needs event orientation and some first-order
  quantification.
• Integrate UML and GIL.
• Integrate analysis capabilities (e.g., model
  checking and simulation)
• Visualization of Analysis results (e.g.,
  animation, traces, etc.)
• Application Smart Cruise Control

19
Component-Based Analysis Tools Amalia

• Need for multiple analysis capabilities
• Typically involves more than one tool using more
  than one representation
• Amalia
• composable analysis components
• One representation format
• Use only as much machinery as necessary

20
Design processing

• Goal Use domain knowledge to automatically
  refine formal specifications into code.
• Problem How to refine abstract models into
  domain-specific implementations
• Solution
• Engineer domain-specific interpretations of
  formal features.
• Transforms map model features into these
  implementations.
• Eventually, formalize the transforms.
• Problem How to combine automated synthesis with
  reuse.

21
Emulation/Simulation of Synthesized Components

• MX simulator being developed to support
  simulation of code that is identical to that
  used in experiments
• Provides socket-level system call interface
• Currently supports C and will eventually
  support Java

22
Validating requirements and refinements

• Problem Non-functional requirements
• (e.g., usability, responsiveness) hard to
  validate analytically.
• Solution Support simulation and prototyping of
  model and code.
• Problem Automated refinements may not preserve
  certain properties of the specifications
• Specifications use multiple paradigms.
• Likely that one paradigm will drive
  synthesis.
• Solution Perform formal analysis of the refined
  code!

23
Case Studies

• Web-based multiparty applications
• WebClass/Pavilion web-based collaborative
  environment (Michigan State University)
• NetMapper network management utility. (Texas
  Instruments)
• On-board control systems
• Automotive applications (e.g., cruise control,
  steering, Siemens Automotive)
• Fault protection system (NASA/JPL).
• Wireless telecommunication services
• Emergency telecomm services implemented over a
  digital radio infra-structure. (Motorola)

24
Overview of talk

• Interactive distributed applications (IDAs).
• Goals and vision.
• Proposed research.
• Validation and contributions.

25
Validation and deliverables

• Validation through extensive case studies.
• Each case study comprises two parts
• Definition existing application guides tool
  development and repository population.
• Validation test framework on a different
  application.
• Deliverables in three increments
• Core suite of tools validated on Web-based
  multi-party apps.
• Incorporate on-board--control domain.
• Incorporate wireless-telecom domain.

26
Contributions

• Enable high-quality IDA development.
• Extend visual development to encompass formal
  reasoning.
• Support reuse at many levels of abstraction using
  a common notation the UML modeling language(s).
• Integrate formal analysis and testing/simulation.
• Automation techniques that span multiple
  development phases.
• E.g., using formal verification of generated code
  to validate an informal refinement.