Permission is granted for noncommercial reproduction of the work for educational or research purposes.

This paper describes Lua, a language for extending applications. Lua combines procedural features with powerful data description facilities, by using a simple, yet powerful, mechanism of tables. This mechanism implements the concepts of records, arrays, and recursive data types (pointers), and adds some object-oriented facilities, such as methods with dynamic dispatching. Lua presents a mechanism of fallbacks that allows programmers to extend the semantics of the language in some unconventional ways. As a noteworthy example, fallbacks allow the user to add different kinds of inheritance to the language. Currently, Lua is being extensively used in production for several tasks, including user configuration, general-purpose data-entry, description of user interfaces, storage of structured graphical metafiles, and generic attribute configuration for finite element meshes.

Intrusion Detection Systems (IDSs) attempt to identify unauthorized use, misuse, and abuse of computer systems. In response to the growth in the use and development of IDSs, we have developed a methodology for testing IDSs. The methodology consists of techniques from the field of software testing which we have adapted for the specific purpose of testing IDSs. In this paper, we identify a set of general IDS performance objectives which is the basis for the methodology. We present the details of the methodology, including strategies for test-case selection and specific testing procedures. We include quantitative results from testing experiments on the Network Security Monitor (NSM), an IDS developed at UC Davis. We present an overview of the software platform that we have used to create user-simulation scripts for testing experiments. The platform consists of the UNIX tool expect and enhancements that we have developed, including mechanisms for concurrent scripts and a record-and-replay ...

When adjusting a graph layout, it is often desirable to preserve various properties of the original graph in the adjusted view. Pertinent properties may include straightness of lines, graph topology, orthogonalities and proximities. A layout adjustment algorithm which can be used tocreate sheye views of nested graphs is introduced. The SHriMP (Simple Hierarchical Multi-Perspective) visualization technique uses this algorithm to create sheye views of nested graphs. This algorithm preserves straightness of lines and uniformly resizes nodes when requests for more screen space aremade. In contrast to other layout adjustment algorithms, this algorithm has several variants to preserve additional selectedproperties of the original graph. These variants use di erent layout strategies to reposition nodes when the graph is distorted. The SHriMP visualization technique is demonstrated through its application to visualizing structures in large software systems.

This paper presents a novel, integrated teaching and learning tool - called digital lecture board - which takes into account the requirements of synchronous, computer-based distance education. For almost two years, the TeleTeaching project Mannheim-Heidelberg has been using video conferencing tools for transmitting lectures and seminars. These tools prove to be insufficient for the purpose of teleteaching since they are not powerful enough to support team work, they are not flexible enough for the use of media, and are somewhat difficult to handle by non-experts. We discuss shortcomings of the existing tools and disclose features we had in mind while designing the digital lecture board. Embedded in a teaching and learning system, the digital lecture board even allows for asynchronous usage modes, for instance, the preparation of lectures. Moreover, we cover implementation issues of the current prototype.

Mosel is a new tool-set for the analysis and verification in Monadic Second-order Logic. In this paper we concentrate on the system's design: Mosel is a tool-set to include a flexible set of decision procedures for several theories of the logic complemented byavariety of support components for input format translations, visualization, and interfaces to other logics and tools. The main distinguishing features of Mosel are its layered approach to the logic, based on a formal semantics for a minimal subset, its modular design, and its integration in a heterogeneous analysis and verification environment.

The SAPPHIRE system is a powerful, extensible, object-oriented toolkit allowing researchers to rapidly build and configure customized speech analysis tools. Implemented in Tcl/Tk and C, the current version of SAPPHIRE provides a wide range of functionality, including the ability to configure and run the SUMMIT speech recognition system. We now use SAPPHIRE widely in almost all aspects of our speech analysis and recognition research.

This document describes Ptolemy II version 0.3. It contains three parts. The first part is a user's guide, which begins with an overview of the objectives of the software, then explains how to construct applets and applications, then reviews the actor libraries, and then concludes with a tutorial on writing actors. The second part documents the software infrastructure. It is meant to complement, not replace, the code documentation. The third part documents the domains that have been written so far. Ptolemy II supports heterogeneous modeling and design of concurrent systems. It is component technology, in that the models are built by interconnecting components. Executable models are constructed under a model of computation, which is the set of "laws of physics" that govern the interaction of components in the model. If the model is describing a mechanical system, then the model of computation may literally be the laws of physics. More commonly, however, it is a set of rules that are more abstract, and provide a framework within which a designer builds models. A set of rules that govern the interaction of components is called the semantics of the model of computation. Each domain implements such a set of rules. Ptolemy II is written entirely in Java, and aims to support the construction of applets, servlets, migrating code, and embedded Java.

With the advancement of hardware technology, it becomes feasible to develop a networked system of pervasive computing platforms that combine programmable general purpose computers with multiple sensing and wireless communication capability. This networked system of programmable sensor nodes, together called a sensor network, poses unique challenges on how information collected by and stored within the sensor network should be queried and accessed, and how concurrent sensing tasks should be programmed from external clients. In this paper, we describe an architecture that facilitates querying and tasking of sensor networks. The key idea to the architecture lies in the development of the Sensor Querying and Tasking Language (SQTL) and the corresponding Sensor Execution Environment (SEE). We model a sensor network as a distributed set of collaborating nodes that carry out querying and tasking activities programmed in SQTL. A frontend node injects a message, that encapsulates an SQTL program, into a sensor node and starts a diffusion computation. A sensor node may diffuse the encapsulated SQTL program to other nodes as dictated by its logic and collaborately perform the specified querying or tasking activity. We will present the SQTL language and demonstrate its applicability using a maximum temperature querying application and a vehicle tracking application.

Abstract – Ad hoc wireless networks of deeply embedded devices such as micro-sensors and microactuators have emerged as one of the key growth areas for wireless networking and computing technologies. So far these networks/systems have been designed with static and custom architectures for specific tasks, thus providing inflexible operation and interaction capabilities. Various architectures are currently trying to make sensor networks programmable and open to transient users. Most of these schemes though, promote algorithms that are too centralized and/or too interactive (i.e. the user is involved in the control loop most of the time), losing the efficiency these highly resource-limited systems need. Our approach employs active networking concepts in the form of lightweight and mobile control scripts that allow the computation, communication, and sensing resources at the sensor nodes to be efficiently harnessed in an applicationspecific fashion. The replication/migration of such scripts in several sensor nodes allows the dynamic deployment of distributed algorithms into the network. Although these mobile control scripts have similarities to mobile agents for traditional data networks, a framework to support them has different considerations than its traditional data network counterpart. The paper discusses these considerations and design choices, and describes SensorWare, our implementation of such a framework. 1 I.