Person:
Rugaber, Spencer

Permanent Link
https://hdl.handle.net/1853/71653
Associated Organization(s)
Organizational Unit
ORCID
ArchiveSpace Name Record

Filters

1996 - 1999 3 2000 - 2005 2
3 2
5
5
5
5
Reset filters

Settings
Author: Stirewalt, R. E. Kurt ×

Publication Search Results

Now showing 1 - 5 of 5
  • Thumbnail Image
    Item
    Dynamic Assembly from Models (DYNAMO)
    (Georgia Institute of Technology, 2005) Rugaber, Spencer ; Stirewalt, R. E. Kurt
    The DYNAMO project is concerned with assembling high-assurance systems from components, and, specifically, with guaranteeing correct interaction of sets of large, heterogeneous components. Several problems must be overcome to provide such guarantees: 1) dealing with the sheer complexity of the individual components and their interoperation; 2) maintaining design integrity and information hiding in the individual components; 3) providing the desired guarantees; and 4) not compromising efficiency while accomplishing the other goals. DYNAMO addresses these problems with several techniques: 1) a layered, implicit-invocation architecture limits complexity by reducing the quantity and nature of allowed interactions; 2) a declarative specification mechanism abstracts away low-level details such as event dispatch and handling and variable updates; and 3) compile- time component wrapper generation removes expensive, inter-layer procedure calls.
  • Thumbnail Image
    Item
    DYNAMO Design Guidebook
    (Georgia Institute of Technology, 2002) McNeely, Corinne ; Rugaber, Spencer ; Stirewalt, R. E. Kurt ; Zook, David
    The DYNAMO project is concerned with the assembly of components of interactive systems. It includes a design method, described in this guidebook, and a set of tools that support it. The DYNAMO design method starts with a declarative model of the assembly expressed using a graphical UML CASE tool. From the declarative model, DYNAMO tools automatically generate C++ wrapper classes that glue the components together. The DYNAMO design method comprises three-phases that refine a conceptual model of a proposed assembly into interrelated components organized into layered mode components. In Phase 0, the environment in which the assembly executes is described in terms of external actors, the assembly itself, the communication among them, and the behavioral properties that the assembly guarantees to maintain. Phase 1 asks the designer to partition the assembly into its constituent components and their relationships, assigning responsibility for external actions and guarantee-maintenance to the components appropriately. Finally, Phase 2 asks the designer to layer the constituents as mode components, where lower-level components communicate status changes upward, and higher-level components make specific service requests of lower-level components. For each phase, the guidebook provide a purpose, a diagrammatic representation that describes the resulting design artifact, a set of steps to create that diagram, and a set of guidelines or design rules for making appropriate design decisions. Each phase is illustrated using the example of a simple text browser assembly. At the end of the document, a glossary of all DYNAMO-related terms is provided.
  • Thumbnail Image
    Item
    Automating UI Generation by Model Composition
    (Georgia Institute of Technology, 1998) Stirewalt, R. E. Kurt ; Rugaber, Spencer
    Automated user-interface generation environments have been criticized for their failure to deliver rich and powerful interactive applications. To specify more powerful systems, designers need multiple, specialized modeling notations. The model composition problem is concerned with automatically deriving powerful, correct, and efficient user interfaces from multiple models specified in different notations. Solutions balance the advantages of separating code generation into specialized code generators with deep, model-specific knowledge against the correctness and efficiency obstacles that result from such separation. We present a solution that maximizes the advantages of separating code generation. In our approach, highly specialized, model-specific code generators synthesize run-time modules from individual models. We address the correctness and efficiency obstacles by formalizing composition mechanisms that code generators may assume and that are guaranteed by a run-time infrastructure. The mechanisms operate to support run-time module composition as conjunctions in the sense defined by Zave and Jackson.
  • Thumbnail Image
    Item
    Automating the Design of Specification Interpreters
    (Georgia Institute of Technology, 1996) Stirewalt, R. E. Kurt ; Rugaber, Spencer ; Abowd, Gregory D.
    In this paper, we demonstrate the use of model checking in an automated technique to verify the operationalization of a declarative specification language. We refer to an interpreter synthesizer as a software tool that transforms a declarative specification into an executable interpreter. Iterative approaches to synthesizer generation refine initial synthesizer designs by validating them over a test suite of specifications. Carefully chosen test suites and structural constraints enable inductive reasoning with support from a model checker to assert the correctness of generated interpreters. This iterative approach to synthesizer generation occurred naturally in our work on developing interpreters for declarative human-computer dialogue languages as part of the DARPA MASTERMIND project. We will discuss the issues underlying the translation, operationalization and verification of the hierarchical task language for MASTERMIND. We will also discuss the importance of this semi-automated, iterative approach for assessing non-functional design tradeoffs.
  • Thumbnail Image
    Item
    The MASTERMIND User Interface Generation Project
    (Georgia Institute of Technology, 1996) Browne, Thomas ; Davila, David ; Rugaber, Spencer ; Stirewalt, R. E. Kurt
    Graphical user interfaces are difficult to construct and, consequently, suffer from high development and maintenance costs. Automatic generation from declarative descriptions can reduce costs and enforce design principles. MASTERMIND is a model based approach to user interface generation. Designers model different aspects of an interface using declarative modeling languages, and tools synthesize these models into run-time code. The design process begins with user task and application modeling. These models are then refined into dialogue, presentation, and interaction models and an application API. These latter models drive the synthesis of run-time code. A design tool called Dukas is employed to support the refinement of task models into dialogue models.