DATE, TIME & PLACE: Febuary 4, 2004, 3 pm, SDSC Auditorium

TALK TITLE: Actor-oriented Metaprogramming

SPEAKER: Steve Neuendorffer ( neuendor@eecs.berkeley.edu ),
Ptolemy Research Group ( http://ptolemy.eecs.berkeley.edu ),
UC Berkeley

SPEAKER HOST: Bertram Ludaescher ( ludaesch@sdsc.edu )

ABSTRACT:
The design of embedded software systems is significantly complicated by the
system's interaction with the physical world. Concurrent interaction and
the passage of time are central to this interaction. Unfortunately, most
software systems practice today relies on programming languages that
primarily represent sequential operations that complete in an unknown
amount of time. Attempts to improve the situation through operating system
mechanisms such as interrupts, timers, and threads often introduce as many
new problems as they solve. These mechanisms provide a programmer with
significant flexibility, while also exposing many programming pitfalls. One
approach to solving this design problem is to provide better programming
languages with structured notions of time and concurrency which can be more
easily understood.

I describe an actor-oriented system modeling approach that forms the basis
for a better way to architect embedded systems. An actor is a completely
encapsulated component that interacts with other actors through explicit
communication channels, rather than through shared memory. Because of this
restriction, the interaction between actors can be understood entirely
through analysis of their interfaces. The interaction between actors can
also be orthogonalized from the actors themselves, allowing it to be
specified separately through a Model of Computation. We specify embedded
systems using Models of Computation that represent time, concurrency, and
interaction with the physical world.

Although we model embedded software using behavioral components, it is
important to recognize that this does not require a run-time component
architecture, such as CORBA. Efficient embedded software can be generated
from actor models by specializing generically specified actors to their
context in a model. We call this approach to system design "Actor-oriented
Metaprogramming" to distinguish it from other component-based techniques.
Metaprogramming allows the use of highly generic and reusable actors for
design without sacrificing implementation efficiency.

This talk will introduce Actors and Models of Computation and talk
specifically about how they are implemented within Ptolemy II. I'll discuss
parts of the framework that enable generic actors and give some examples of
heterogenous modeling.

ABOUT THE SPEAKER:
Steve Neuendorffer is one of the principal architects of Ptolemy II,
a high level modeling program which has received extensive funding
from DARPA. His areas of expertise are programming languages, system
modeling and synthesis, embedded software, and software engineering.
Steve did his undergraduate work at the University of Maryland and his
Masters Degree in EECS at Berkeley. He is currently finishing his PhD
work at UC Berkeley, EECS.