Showing papers in "IEEE Computer in 1992"

Mediators in the architecture of future information systems

Abstract: For single databases, primary hindrances for end-user access are the volume of data that is becoming available, the lack of abstraction, and the need to understand the representation of the data. When information is combined from multiple databases, the major concern is the mismatch encountered in information representation and structure. Intelligent and active use of information requires a class of software modules that mediate between the workstation applications and the databases. It is shown that mediation simplifies, abstracts, reduces, merges, and explains data. A mediator is a software module that exploits encoded knowledge about certain sets or subsets of data to create information for a higher layer of applications. A model of information processing and information system components is described. The mediator architecture, including mediator interfaces, sharing of mediator modules, distribution of mediators, and triggers for knowledge maintenance, are discussed. >

Applying 'design by contract'

Abstract: Methodological guidelines for object-oriented software construction that improve the reliability of the resulting software systems are presented. It is shown that the object-oriented techniques rely on the theory of design by contract, which underlies the design of the Eiffel analysis, design, and programming language and of the supporting libraries, from which a number of examples are drawn. The theory of contract design and the role of assertions in that theory are discussed. >

The Stanford Dash multiprocessor

Abstract: The overall goals and major features of the directory architecture for shared memory (Dash) are presented. The fundamental premise behind the architecture is that it is possible to build a scalable high-performance machine with a single address space and coherent caches. The Dash architecture is scalable in that it achieves linear or near-linear performance growth as the number of processors increases from a few to a few thousand. This performance results from distributing the memory among processing nodes and using a network with scalable bandwidth to connect the nodes. The architecture allows shared data to be cached, significantly reducing the latency of memory accesses and yielding higher processor utilization and higher overall performance. A distributed directory-based protocol that provides cache coherence without compromising scalability is discussed in detail. The Dash prototype machine and the corresponding software support are described. >

Functional-link net computing: theory, system architecture, and functionalities

Abstract: A system architecture and a network computational approach compatible with the goal of devising a general-purpose artificial neural network computer are described. The functionalities of supervised learning and optimization are illustrated, and cluster analysis and associative recall are briefly mentioned. >

Load distributing for locally distributed systems

Abstract: The problem of judiciously and transparently redistributing the load of the system among its nodes so that overall performance is maximized is discussed. Several key issues in load distributing for general-purpose systems, including the motivations and design trade-offs for load-distributing algorithms, are reviewed. In addition, several load-distributing algorithms are described and their performances are compared. These algorithms are sender-initiated algorithms, receiver-initiated algorithms, symmetrically initiated algorithms, and adaptive algorithms. Load-distributing policies used in existing systems are examined, and conclusions about which algorithm might help in realizing the most benefits of load distributing are drawn. >

The usability engineering life cycle

Abstract: A practical usability engineering process that can be incorporated into the software product development process to ensure the usability of interactive computer products is presented. It is shown that the most basic elements in the usability engineering model are empirical user testing and prototyping, combined with iterative design. Usability activities are presented for three main phases of a software project: before, during, and after product design and implementation. Some of the recommended methods are not really single steps but should be used throughout the development process. >

A prototype document image analysis system for technical journals

Abstract: Gobbledoc, a system providing remote access to stored documents, which is based on syntactic document analysis and optical character recognition (OCR), is discussed. In Gobbledoc, image processing, document analysis, and OCR operations take place in batch mode when the documents are acquired. The document image acquisition process and the knowledge base that must be entered into the system to process a family of page images are described. The process by which the X-Y tree data structure converts a 2-D page-segmentation problem into a series of 1-D string-parsing problems that can be tackled using conventional compiler tools is also described. Syntactic analysis is used in Gobbledoc to divide each page into labeled rectangular blocks. Blocks labeled text are converted by OCR to obtain a secondary (ASCII) document representation. Since such symbolic files are better suited for computerized search than for human access to the document content and because too many visual layout clues are lost in the OCR process (including some special characters), Gobbledoc preserves the original block images for human browsing. Storage, networking, and display issues specific to document images are also discussed. >

A taxonomy and current issues in multidatabase systems

Abstract: A taxonomy of global information-sharing systems is presented, and the way in which multidatabase systems fit into the spectrum of solutions is discussed. The taxonomy is used as a basis for defining multidatabase systems. Issues associated with multidatabase systems are reviewed. Two major design approaches for multidatabases, global schema systems and multidatabase language systems, are described. Existing multidatabase projects and areas for further research are also discussed. >

Authentication for distributed systems

Abstract: A number of protocols used to authenticate users, hosts and processes are described. The three main types of authentication in a distributed computing system-message content authentication, message origin authentication, and general identity authentication-are explained. Authentication exchanges are identified, and paradigms of authentication protocols are presented. Authentication protocol failures are addressed, and an authentication framework is provided. As case studies, two authentication services, Kerberos and SPX, are examined. >

DDM-a cache-only memory architecture

Abstract: The Data Diffusion Machine (DDM), a cache-only memory architecture (COMA) that relies on a hierarchical network structure, is described. The key ideas behind DDM are introduced by describing a small machine, which could be a COMA on its own or a subsystem of a larger COMA, and its protocol. A large machine with hundreds of processors is also described. The DDM prototype project is discussed, and simulated performance results are presented. >

The many faces of consensus in distributed systems

Abstract: Known results regarding consensus among processors are surveyed and related to practice. The ideas embodied in the various proofs are explained. The goal is to give practitioners some sense of the system hardware and software guarantees that are required to achieve a given level of reliability and performance. The survey focuses on two categories of failures: fail-stop failures, which occur when processors fail by stopping; and Byzantine failures, which occur when processors fail by acting maliciously. >

The RightPages image-based electronic library for alerting and browsing

Abstract: The RightPages electronic library prototype system, which gives users full online library services, is described. The prototype takes advantage of fast hardware, multimedia workstations, and broadband networks to process scientific and technical journals for users and to offer a service that: alerts them to the arrival of new journal articles matching their interest profiles; lets them immediately examine images of pages in the alerted articles and browse through other articles in the database; and enables them to order paper copies of any articles in the database. The system runs on a local area network that connects one or more scanning stations, a centralized document database server and multiple user stations running X Windows servers. The RightPages interface runs as an X Windows application on Sun workstations or X terminals. The system's image and document processing, including noise reduction, document layout analysis, text processing, and display processing are discussed. >

Biting the silver bullet: toward a brighter future for system development

Abstract: The author responds to two discouraging position papers by F.B. Brooks, Jr. (see ibid., vol.20, no.4, p 10-19, 1987) and D.L. Parnas (see Commun. ACM, vol.28, no.12, p.1326-35, 1985) regarding the potential of software engineering. While agreeing with most of the specific points made in both papers, he illuminates the brighter side of the coin, emphasizing developments in the field that were too recent or immature to have influenced Brooks and Parnas when they wrote their manuscripts. He reviews their arguments, and then considers a class of systems that has been termed reactive, which are widely considered to be particularly problematic. He reviews a number of developments that have taken place in the past several years and submits that they combine to form the kernel of a solid general-purpose approach to the development of complex reactive systems. >

Object-oriented and conventional analysis and design methodologies

Abstract: Three object-oriented analysis methodologies and three object-oriented design methodologies are reviewed and compared to one another. The authors' intent is to answer the question of whether emerging object-oriented analysis and design methodologies require incremental or radical changes on the part of prospective adopters. The evolution of conventional development methodologies is discussed, and three areas-system partitioning, end-to-end process modeling, and harvesting reuse-that appear to be strong candidates for further development work are presented. >

From paper to office document standard representation

Abstract: The principles of the model-based document analysis system called Pi ODA (paper interface to office document architecture), which was developed as a prototype for the analysis of single-sided business letters in German, are presented. Initially, Pi ODA extracts a part-of hierarchy of nested layout objects such as text-blocks, lines, and words based on their presentation on the page. Subsequently, in a step called logical labeling, the layout objects and their compositions are geometrically analyzed to identify corresponding logical objects that can be related to a human perceptible meaning, such as sender, recipient, and date in a letter. A context-sensitive text recognition for logical objects is then applied using logical vocabularies and syntactic knowledge. As a result, Pi ODA produces a document representation that conforms to the ODA international standard. >

Color and sound in algorithm animation

Abstract: The techniques developed by M. M. Brown and R. Sedgewick (1985) in using the Balsa algorithm-animation system are reviewed. Techniques that focus on color and sound, areas just opening up in workstation-based interactive algorithm-animation systems, are described. Color is used for encoding the state of data structures, highlighting activity, trying multiple views together, emphasizing patterns, and making an algorithm's history visible in a single static image. Sound is used for reinforcing visuals, conveying patterns, replacing visuals, and signaling exceptional conditions. The techniques are based on work done with the Zeus algorithm-animation system. Six screen dumps from six different algorithm animations that are representative of the was Zeus was used are presented. >

An interpretation system for land register maps

Abstract: A system for the automatic acquisition of land register maps is described. The system converts paper-based documents into digital form for integration into an existing database. Processing a map begins with its digitization by a scanning device. A key step in the system is the conversion from raster format to graph representation, a special binary image format suitable for processing line structures. Subsequent steps include vectorization of the line structures and recognition of the symbols interspersed in the drawing. The system requires operator interaction only to resolve ambiguities and correct errors in the automatic processes. The final result is a set of descriptors for all detected map entities, which is then stored in a database. It is shown that the image representation, vectorization techniques, and optical character recognition subsystem are quite general and that the methodology implemented in the system can be generalized to the acquisition of other classes of line drawings. >

High-performance logic programming with the Aquarius Prolog compiler

Abstract: Aquarius Prolog, a high performance compiler designed and built to test the hypothesis that Prolog can be implemented as efficiently as an imperative language by compiling the more powerful features of logic programming only where they are needed, and then only in the simplest form, is described. The authors begin with some background on logic programming and then discuss the Prolog language in more detail. They present an overview of their compiler, giving its structure and the principles underlying its high performance. They compare their system with two popular high-performance commercial systems and with two implementations of C and conclude with an overview of ways to extend this work. >

Parallel programming using shared objects and broadcasting

Abstract: The two major design approaches taken to build distributed and parallel computer systems, multiprocessing and multicomputing, are discussed. A model that combines the best properties of both multiprocessor and multicomputer systems, easy-to-build hardware, and a conceptually simple programming model is presented. Using this model, a programmer defines and invokes operations on shared objects, the runtime system handles reads and writes on these objects, and the reliable broadcast layer implements indivisible updates to objects using the sequencing protocol. The resulting system is easy to program, easy to build, and has acceptable performance on problems with a moderate grain size in which reads are much more common than writes. Orca, a procedural language whose sequential constructs are roughly similar to languages like C or Modula 2 but which also supports parallel processes and shared objects and has been used to develop applications for the prototype system, is described. >

Demonstrational interfaces: A step beyond direct manipulation

Abstract: Demonstrational interfaces, interfaces that let the user perform actions on concrete example objects while constructing an abstract program, thus letting the user create parameterized procedures and objects without learning a programming language, are discussed. The motivations for and problems associated with demonstrational interfaces are presented. A survey of the various types of interfaces is also presented. Areas that would benefit from demonstrational technology, including general-purpose programming, visualization, macros for direct-manipulation interfaces, drawing packages, text editing and formatting, and user interface development environments, are discussed. Research issues involving demonstrational interfaces are reviewed. >

Architecture of an open object-oriented database management system

Abstract: The architecture of the open object-oriented database (OODB) management system, its requirements, and its computational model, which builds database functionality as an extensible collection of transparent extensions to existing programming languages, are described. The way in which open OODB's system architecture is decomposed into a kernal meta-architecture and a collection of modules implementing specific behavioral extensions is discussed. The potential risks of the open OODB architecture are reviewed. >

Information encoding with two-dimensional bar codes

Abstract: Various schemes proposed for storing more information in the bar code label are reviewed. The concept of information density is introduced. The constraints imposed by the reading technology are addressed, and various recently proposed stacked bar codes are surveyed. Certain non-bar-code solutions are discussed. >

Using tool abstraction to compose systems

Abstract: The tool abstraction paradigm, which supports the evolution of large-scale software systems by easing design changes in the system functions, is discussed. Systems that support tool abstraction are structured as a pool of abstract data structures shared by a collection of cooperating 'toolies', where each toolie provides a piece of the overall system function. When one toolie updates the shared data, other toolies must be notified: otherwise, cooperating-but-independent toolies may not execute, and the overall system function may be compromised. The KWIC (key word in context) index production system is used to illustrate the idea of tool abstraction. The relationship of tool abstraction to other concepts is examined. >

Mapping computer-vision-related tasks onto reconfigurable parallel-processing systems

Abstract: A tutorial overview of how selected computer-vision-related algorithms can be mapped onto reconfigurable parallel-processing systems is presented. The reconfigurable parallel-processing system assumed for the discussions is a multiprocessor system capable of mixed-mode parallelism; that is, it can operate in either the SIMD or MIMD modes of parallelism and can dynamically switch between modes at instruction-level granularity with generally negligible overhead. In addition, it can be partitioned into independent or communicating submachines, each having the same characteristics as the original machine. Furthermore, this reconfigurable system model uses a flexible multistage cube interconnection network, which allows the connection patterns among the processors to be varied. It is demonstrated how reconfigurability can be used by reviewing and examining five computer-vision-related algorithms, each one emphasizing a different aspect of reconfigurability. >

Authentification for Distributed Systems.

Abstract: A number of protocols used to authenticate users, hosts and processes are described. The three main types of authentication in a distributed computing system-message content authentication, message origin authentication, and general identity authentication-are explained. Authentication exchanges are identified, and paradigms of authentication protocols are presented. Authentication protocol failures are addressed, and an authentication framework is provided. As case studies, two authentication services, Kerberos and SPX, are examined. >

Protein-based optical computing and memories

Abstract: The current and potential uses of bacteriorhodopsin in optical computing and memory devices are reviewed. The protein has significant potential for use in these applications due to unique intrinsic photophysical properties, and the range of chemical and genetic methods available for optimizing performance for specific application environments. The intrinsic properties of the native bacteriorhodopsin protein are described. The applications of bacteriorhodopsin in spatial light modulators, integral components in a majority of one-dimensional and two-dimensional optical processing environments, and holographic associative memories are presented. >

Touring Machines: autonomous agents with attitudes

Abstract: A multilayered integrated architecture for controlling autonomous mobile agents, or Touring Machines, is introduced. This architecture combines capabilities for producing a range of reactive and deliberative behaviors in dynamic, unpredictable domains. The approach is influenced by recent work on reactive and behavior-based agent architectures. Touring Machines blend sophisticated and simplified control features. Experience shows that this layered architecture can be configured to behave with robustness and flexibility simultaneously in dynamic settings. The implementation of the control architecture on a testbed is reported. >

Celesstin: CAD conversion of mechanical drawings

Abstract: Celesstin, a system that converts mechanical engineering drawings into a format suitable for CAD, is described. Celesstin integrates several modules in a blackboard-based interpretation system. Once a drawing has been digitized, a first processing step separates the text and the dimensioning lines from the pure graphics part. Celesstin vectorizes the graphics part and assembles the resulting lines into blocks, the basic elements for the technical entities that it creates. The result is transferred to the CAD system. Celesstin tries to match the extracted entities with the corresponding models from the CAD library. It puts the remaining blocks and lines into different layers of the CAD description. The system is based on the assumption that even when the vectorized drawing is distorted, it can be correctly interpreted by using knowledge about the representation rules used in technical drawings and about the manufacturing technology associated with the represented objects. >

RCS: a reference model architecture for intelligent control

Abstract: The real-time control system (RCS), a reference model architecture for intelligent real-time control systems, is described. It partitions the control problem into four basic elements: task decomposition, world modeling, sensory processing and value judgment. RCS clusters these elements into computational nodes that control specific subsystems, and arranges these nodes in hierarchical layers so that each layer has characteristic functionality and timing. The RCS architecture has a systematic regularity and recursive structure that suggests a canonical form. Four versions of RCS have been developed. The application of one of the versions to machining workstation consisting of a part buffer, a machine tool and a robot is examined. The functionality of each of the levels in the control hierarchy is discussed. >

An object-oriented real-time programming language

Abstract: The real-time object model, an extended object-oriented model for describing real-time systems, is described. The design and implementation of RTC++, a programming language that extends C++ on the basis of the real-time object model, are discussed. The schedulability analysis and specification of rigid timing constraints in systems with active objects are reviewed. >