Meetings comprise a vital part of participation in social activities. For a deaf or hard of hearing person who does not understand spoken language, following meetings can become confusing if there are too many simultaneous sources of information. When the person focuses on one source of information, she misses information from another source; for example, while looking at a presenter's slides, the person misses information from the signing interpreter. The features of Facetop Tablet were iteratively designed according to feedback from members of the Deaf community. Through this feedback, we have refined and completed the implementation and it is ready for evaluation through user studies. We are ready to recruit participants whom we could reach through demonstrations.

We present an overview of SPQR, the System for Pattern Query and Recognition, a toolkit that detects instances of known design patterns directly from object-oriented source code in an automated and flexible manner. Based on our previous work in ñ-calculus and Pattern/Object Markup Language (POML), SPQR is retargetable to most OO languages, and system design notations. We discuss how this approach may be applied to architectural concerns by leveraging SPQR’s training mode. The System for Pattern Query and Recognition, or SPQR, is an automated framework to analyze software systems in the small or the large, and detect instances of known programming concepts in a flexible yet formal manner. These concepts, combined in well-defined ways to form abstractions, as found in the design patterns literature, then lead to the possible automated detection of design patterns directly from source code and other design artifacts. Our previous publications [7, 8] have described SPQR in detail, as well as its successful application to a number of software systems. Here we describe SPQR briefly, and how these principles can be extended to architectural analysis.

Program federation is assembling a software system from cooperating but independent application programs. We present DeCo, a declarative approach to creating and coordinating federations, and discuss its application in the domain of scientific computing. DeCo is meant to automate several aspects of the typically manual process of program federation. A federation is expressed in the functional language Haskell, extended with constructs for describing and coordinating the participating programs and data files. The declarative expression of a federation in terms of data flow among the component programs captures synchronization requirements implicitly and exploits the inherent concurrency automatically. Haskell compilation, notably its rigorous type checking, ensures the consistency of the federation. Operation of the coordination framework is demonstrated on a federation of FORTRAN programs that simulate environmental processes in the Neuse River estuary of North Carolina.

Previous automated approaches to discovering design patterns in source code have suffered from a need to enumerate static descriptions of structural and behavioral relationships, resulting in a finite library of variations on pattern implementation. Our approach, system for pattern query and recognition, or SPQR, differs in that we do not seek statically to encode each variant of the patterns that we wish to find. Our system finds pattern variants that were not explicitly defined, but instead are inferred dynamically during code analysis by a theorem prover, providing practical tool support for software construction, comprehension, maintenance, and refactoring. We use a logical inference system to reveal large numbers of patterns and their variations from a small number of definitions by encoding in a formal denotational semantics a small number of fundamental OO concepts (elemental design patterns), encode the rules by which these concepts are combined to form patterns (reliance operators), and encode the structural/behavioral relationships among components of objects and classes (rho-calculus). A chain of fully automated tools provides a path from source code to revealed patterns. We describe our approach in this paper with a concrete example to drive the discussion, accompanied by formal treatment of the foundational topics.

HTML documents composed of frames can be difficult to write correctly. We demonstrate a technique that can be used by authors manually creating HTML documents (or by document editors) to verify that complex frame construction exhibits the intended behavior when browsed. The method is based on model checking (an automated program verification technique), and on temporal logic specifications of expected frames behavior. We show how to model the HTML frames source as a CobWeb protocol, related to the Trellis model of hypermedia documents. We show how to convert the CobWeb protocol to input for a model checker, and discuss several ways for authors to create the necessary behavior specifications. Our solution allows Web documents to be built containing a large number of frames and content pages interacting in complex ways. We expect such Web structures to be more useful in "literary" hypermedia than for Web "sites" used as interfaces to organizational information or databases.

We present a view of hyperdocuments in which each document encodes its own browsing semantics in its links. This requires a mental shift in how a hyperdocument is thought of abstractly. Instead of treating the links of a document as defining a static directed graph, they are thought of as defining an abstract program, termed the links-automaton of the document. A branching temporal logic notation, termed HTL*, is introduced for specifying properties a document should exhibit during browsing. An automated program verification technique called model checking is used to verify that browsing specifications in a subset of HTL* are met by the behavior defined in the links-automation. We illustrate the generality of these techniques by applying them first to several Trellis documents and then to a Hyperties document.

Daistish is a tool that performs systematic algebraic testing similar to Gannon's DAISTS tool [2]. However, Daistish creates effective test drivers for programs in languages that use side effects to implement ADTs; this includes C++ and most other object-oriented languages. The functional approach of DAISTS does not apply directly in these cases. The approach in our work is most similar to the ASTOOT system of Doong and Frankl [1]; Daistish differs from ASTOOT by using Guttag-style algebraic specs (functional notation), by allowing aliasing of type names to tailor the application of parameters in test cases, and by retaining the abilities of DAISTS to compose new test points from existing ones. Daistish is a Perl script, and is compact and practical to apply. We describe the implementation and our experiments in both Eiffel and C++. Our work has concentrated on solving the semantics-specific issues of correctly duplicating objects for comparison; we have not worked on methods for selecting specific test cases.Daistish consists of a perl script and supporting documentation. The current distribution can be obtained via WWW at URLhttp://www.cs.unc.edu/~stotts/Daistish/

The correct and timely creation of systems for coordination of group work depends on the ability to express, analyze, and experiment with protocols for managing multiple work threads. We present an evolution of the Trellis model that provides a formal basis for prototyping the coordination structure of a collaboration system. In Trellis, group interaction protocols are represented separately from the interface processes that use them for coordination. Protocols are interpreted (rather than compiled into applications) so group interactions can be changed as a collaborative task progresses. Changes can be made either by a person editing the protocol specification “on the fly” or by a silent “observation” process that participates in an application solely to perform behavioral adaptations.

Abstract We describe a program for the display and exploration of complex, domain‐specific information: ytracc, an interactive grammar debugging tool for compiler writers. The ytracc system provides the designer of a yacc grammar a method of tracing a parser as it uses the grammar, ytracc captures the states of the parse as it is carried out. The captured parse can then be replayed forwards or backwards, step‐by‐step, or subtree‐by‐subtree, as defined by the non‐terminals of the grammar. The tool has been successfully used by students as an assistant in an advanced undergraduate compiler construction class, and we use the tool in our everyday work.

We present a formal definition of the Trellis model of hypertext and describe an authoring and browsing prototype called αTrellis that is based on the model. The Trellis model not only represents the relationships that tie individual pieces of information together into a document (i.e., the adjacencies), but specifies the browsing semantics to be associated with the hypertext as well (i.e., the manner in which the information is to be visited and presented). The model is based on Petri nets, and is a generalization of existing directed graph-based forms of hypertext. The Petri net basis permits more powerful specification of what is to be displayed when a hypertext is browsed and permits application of previously developed Petri net analysis techniques to verify properties of the hypertext. A number of useful hypertext constructs, easily described in the Trellis model, are presented. These include the synchronization of simultaneous traversals of separate paths through a hypertext, the incorporation of access controls into a hypertext (i.e., specifying nodes that can be proven to be accessible only to certain classes of browsers), and construction of multiple specialized (tailored) versions from a single hypertext.