bluuebunny/crossref_metadata_2025_split huggingface dataset:
Computer human factors in computer interface design (panel session)
Authors: Moran Thomas , Olson Judith Reitman , Wixon Dennis , Whiteside John , Mack Robert 
Published: January 2007

Human factors psychologists contribute in many ways to improving human-computer interaction. One contribution involves evaluating existing or prototype systems, in order to assess usability and identify problems. Another involves contributing more directly to the design of systems in the first place: that is, not only evaluating systems but bringing to bear empirical methods and theoretical considerations that help specify what are plausible designs in the first place. The goal of this panel is to discuss four case studies emphasizing this role of cognitive human factors, and identify relevant methods and theoretical considerations.
The panelists will present examples of prototypes or products to whose design they contributed, with the aim of characterizing the problem (or problems) they tried to solve, the approach to identifying a design solution for that problem, and evidence that the approach was useful.
Robert Mack will discuss an editor prototype designed to get novices started doing meaningful work quickly and helping them to continue acquiring new skills, with virtually no explicit instruction. The prototype is being designed in large part by identifying key novice problems and expectations, and trying to design the interface to better accommodate these expectations. The first goal of getting novices started relatively quickly has been achieved but problems remain as novices try to acquire further text-editing skill. These problems — and solutions to them — are being identified through a process of iterative design and evaluation.
Dennis Wixon will discuss implications for designing usable interfaces of the User-Derived-Interface project (Good, M., Whiteside, J., Wixon, D. and Jones, S., 1984). The project involved a simulation of a restricted natural language interface for an electronic mail system. The design process was driven by the behavioral goal of getting users started relatively quickly with little or no instruction or interface aids. Actual user interaction with the simulation coupled with iterative design and evaluation provided interface specifications. This prototype illustrates a number of techniques for bringing usability into the software engineering process.

These presentations will discuss the role of empirical methods such as
verbal protocol techniques
for identifying user problems with existing computer systems (e.g., Lewis, 1982; Mack, Lewis & Carroll, 1983; Douglas & Moran, 1983), including variations aimed at identifying user expectations that may be able to guide design (e.g., Mack, 1984);
interface simulations
for studying user interactions again with the aim of letting user behavior guide interface design (e.g., Kelley, 1984; Good, Whiteside, Wixon & Jones, 1984), and
iterative design and evaluation
of interfaces, aimed at achieving behavioral goals (e.g., Carroll & Rosson, 1984; Gould & Lewis, 1983).
Whiter (or wither) UIMS?
Authors: Olsen Dan R. , Green Mark , Lantz Keith A. , Schulert Andrew , Sibert John L. 
Published: January 2007

The subject of User Interface Management Systems (UIMS) has been a topic of research and debate for the last several years. The goal of such systems has been to automate the production of user interface software. The problem of building quality user interfaces within available resources is a very important one as the demand for new interactive programs grows. Prototype UIMSs have been built and some software packages are presently being marketed as such. Many papers have been published on the topic.
There still, however, remain a number of unanswered questions. Is a UIMS an effective tool for building high quality user interfaces or is the run-time cost of abstracting out the user interface too high? Why are there not more UIMSs available and why are they not more frequently used? Is simple programmer productivity alone sufficient motivation for learning and adopting yet another programming tool? What is the difference, if any, between a “user interface toolbox”, a windowing system and a UIMS? What are the differences between a UIMS and the screen and editor generators found in fourth generation languages? In fact, exactly what is a UIMS?
In order to discuss these questions and to reassess the state of the UIMS art, SIGGRAPH sponsored a workshop on these issues (proceedings will be published in Computer Graphics in 1987). The panelists represent four subgroups who have each addressed these problems from different points of view.
3D layout manipulation functions with a glance to optimization problems
Authors: Capra Renato 
Published: January 2007

APL syntax provides a very simple and expressive way to generate and manipulate simple 3D parametric objects. APL2 nested arrays provide powerful data structures for a compact, readable and executable description of 3D layout scenes.
The paper describes a user-friendly interactive graphic system for 3D layout manipulation. The user can define and modify a layout scene by graphical interaction on a 3D perspective projection. User's commands enable change of parameters, 3D transformations and friendly operations that involve position relationship between objects. Commands are translated into “messages” to graphic objects, and the result of the operations is immediately reflected in a modification of the “scene data structure”.
The system includes the capability to select objects from a catalogue, to build compound objects and to edit sub-objects. The scene data structure is well suited for interface to external graphics rendering programs. Data structure can be extended to include non-geometrical information. Moreover it is possible to apply complex numerical algorithms to geometrical and numerical data.
A heuristic algorithm for Satellite Systems Layout Optimization is presented as an example.
Petri-net evaluation using APL2
Authors: Willhoft Robert G. 
Published: January 2007

A Petri net is a graphical and mathematical modeling tool useful in the analysis of concurrent, asynchronous, distributed, parallel, nondeterministic, and/or stochastic systems. In addition, interest in Petri nets is increasing in the software community to model the behavior of parallel computer programs. The introduction of timed Petri nets allows system or program performance to be estimated as well.
This paper begins with a general discussion, including definitions, for both ordinary and timed Petri nets. Several analysis tools are outlined for ordinary and timed Petri nets including analysis of the incidence matrix, coverability tree, firing diagram, and the GRID (Graph of Reachable Instantaneous Descriptions).
This paper then introduces a method for representing Petri nets in APL2 and defines an easy input method. An APL2 implementation of each of the above analysis tools is given. These functions are described in detail as to their operation. Several examples of their use are given including examples of deadlock detection and performance estimation.
Parallel simulation of stochastic petri nets using recurrence equations
Authors: Baccelli François , Canales Miguel 
Published: January 2007

Petri nets provide a powerful modeling formalism, which allows one to describe and study various classes of systems, such as synchronous and asynchronous processes, and/or parallel or sequential ones.
We present below a software package, currently under development, that allows the user to specify a stochastic marked graph [1] using either a graphical interface or a specification language. From this specification a simulation program for a Single Instruction Multiple Data (SIMD) parallel machine is generated. A Connection Machine 2 (CM2) is used as the architecture for running this program.
Expert systems in government
Authors: Leach Stephen P. , Kandel Abraham 
Published: January 2007

The process of redistricting involves the division of a land surface into two or more pieces. In a political setting, the districts thus formed provide groups of voters that elect the same public officials. Other types of redistricting applications include the formation of school districts, transportation districts, or water management districts.
In this work we describe a knowledge-based expert system, Grouper, as a solution to the redistricting problem. A number of key issues are addressed by the solution, including equality of population, contiguity, and graphical display of possible districts. In addition, we outline a method (the Grouper approach) for dramatically reducing the complexity of the redistricting problem by limiting activity to a specific level of detail.
A PC-based, prototype solution, implemented using the M.1 expert system shell, is described with emphasis on techniques for minimizing search. An annotated Grouper session is included. Lastly, there is a discussion of the far-reaching significance of the redistricting problem and promising uses or extensions of the Grouper system in this regard.
Integrating analysis and design methods (abstract)
Authors: Coleman Derek , Jeremaes Paul 
Published: January 2007

Most of those who practice object-oriented analysis and design do not follow any standard method exactly, but combine different techniques to suit their own unique requirements. Each method employs its own set of models, notations, and processes, so it can be difficult to combine them. This tutorial shows how to design a method by providing a framework for understanding and evaluating current methods, applying it to three recent methods (OMT (Rumbaugh et al), Responsibility Driven Design/CRC cards, Booth 91 Method), and combining them to produce a new method, FUSION, that builds on their best aspects.
The tutorial introduces a set of criteria for evaluating methods from the viewpoint of the object-oriented concepts they support, the kinds of models and notations they employ and the process steps that they recommend. The criteria provides a way to understand the underlying similarities and differences between methods.
The criteria were developed as part of a program to assess what kind of method should be made available to HP engineers, which led to the development of the FUSION method. The tutorial ends with a brief account of the usefulness of FUSION in practice.
Object-oriented concurrent programming (abstract)
Authors: Briot Jean-Pierre 
Published: January 2007

This tutorial treats object-oriented concurrent programming (OOCP) as the natural generalization of object-oriented programming. OOCP decomposes a large program into a collection of small modules that run and interact concurrently and are capable of exploiting parallel hardware. The tutorial describes various levels of integration between object-oriented programming and concurrency, leading to the notion of an active object, which unifies object and activity, message passing and synchronization.
The tutorial introduces Concurrent Smalltalk to describe concepts, constructs, and methodology. Examples include programming with continuations, divide and conquer, and pipelining. It also shows how to implement active objects, and uses Actalk as an example. Finally, it compares various OOP models and languages, with a special focus on the Actor computation model.
Although the tutorial uses Smalltalk for examples, you dont need to know Smalltalk to understand it; a quick introduction to Smalltalk syntax is included. It assumes that you understand object-oriented programming well, but little more about concurrency than intuitive concepts of processes and synchronization.
Simulation with DEVS-CLOS (abstract)
Authors: Sevinc Suleyman 
Published: January 2007

This tutorial has two purposes: to show how the features of CLOS affect a design and to describe the design of a general-purpose simulation system. The tutorial is designed for those who want to understand the practical importance of the unique features of CLOS and also those who would like to learn how to use or build object-oriented simulation systems.
The tutorial emphasizes the underlying model of object-oriented programming in CLOS and distinguishes it from other models. It also describes the requirements of a simulation system and the design of DEVS-CLOS, a publicly available simulation system. DEVS-CLOS is an extension to CLOS that supports modeling and simulation. It supports visualization, supports hierarchical design of simulations, allows first-order logic in models, and supports adaptive system simulation. The tutorial shows how a system like DEVS-CLOS can be used to solve typical simulation problems, and how CLOS concepts like multimethods, multiple inheritance, pre- and post-methods and dispatching algorithms were used in the design of DEVS-CLOS.
Writing efficient C++ programs (abstract)
Authors: Meyers Scott 
Published: January 2007

This tutorial teaches the competing meanings of high performance; the characteristics of object-oriented systems that can decrease performance; how to locate and eliminate computational bottlenecks in C++ programs; and the trade-offs between high performance and system reusability, maintainability, and portability. It describes in detail the factors that affect the performance of C++ software. Whether your primary concern is high system speed, small system size, fast recompilation, or a combination of these, this tutorial provides you with the tools necessary to come up with an appropriate object- oriented design, to implement it efficiently in C++, and to fine-tune it for maximum performance.
The reasons for bottlenecks in C++ programs are often surprising. Contrary to popular belief, virtual functions usually exact a negligible performance cost, while unexpected calls to constructors and destructors frequently hamstring applications. This tutorial teaches you what is really important if you want to deliver high performance, and the techniques you need to achieve it.
Visual programming languages from an object-oriented perspective (abstract)
Authors: Ambler Allen L. , Burnett Margaret M. 
Published: January 2007

Visual programming language research has evolved greatly since its early days. At first, attempts at visual programming mostly took the form of flowchart-like diagrams. But in recent years, a wide number of innovative approaches have been incorporated into visual languages, including object-oriented programming, form-based programming, programming by demonstration, and dataflow programming. Unfortunately, while many of these systems represent important ideas, only a few have been successful as complete visual programming languages. This tutorial explains why this is true, and describes ways in which the problem can be addressed.
This tutorial explores the issues behind the successes and failures of earlier approaches from a design perspective. It identifies characteristics of successful visual programming languages, and explains how to design an object-oriented language that maintains those characteristics. It shows solutions to a number of problems by looking at existing visual programming languages, including Prograph.
Sniff (abstract)
Authors: Bischofberger Walter R. 
Published: January 2007

Sniff is a pragmatic C++ programming environment which has been
implemented during the last fifteen months. Sniff is implemented in
C++ with the ET++ application framework. It runs on a large number
of UNIX workstations under several window management systems such
as OSF-Motif, OpenWindows, and Sunview. Sniff is an open
environment providing browsing, cross-referencing, design
visualization, documentation, and editing support. It delegates
compilation and debugging to any C++ compiler and debugger of
choice. Sniff has been in internal use at UBS (Union Bank of
Switzerland) since August 1991. Since then several developers have
applied Sniff in developing non- trivial software systems as well
as in evolving Sniff. Public domain distribution off Sniff will
commenced in May 1992.
The main goal in developing Sniff was to create an efficient
portable C++ programming environment which makes it possible to
edit and browse large software systems textually and graphically
with a high degree of comfort, without wasting huge amounts of RAM
or slowing down in an annoying way. A further goal was to achieve
applicable results within one person year.
Multiple-view CASE support for object-oriented design (abstract)
Authors: Chyou Shang-cheng 
Published: January 2007

Object-Oriented Programming (OOP) has been recognized to have
great potential in producing high quality, large reusable software.
However, we often find it difficult to write good C++ or Smalltalk
programs. Without good program designs we will not reap the
benefits of OOP. On the other hand, Object-Oriented Design (OOD) is
considerably more complex than that of the traditional design
disciplines such as Structured Design. Therefore, without the help
of powerful CASE tools, we may not achieve the benefits of OOD and
OOP.
This demonstration will present TurboCASE, a multi-methodology
supporting CASE tool that supports both Object-Oriented Analysis
(OOA) and OOD. TurboCASE provides multiple views to help software
designers create good OOD models.
TurboCASE allows you to create and maintain Class Hierarchy,
Class Collaboration, Class Definition, and Class Design Diagrams.
The Class Hierarchy Diagram not only shows the class hierarchy, but
also helps resolve how polymorphism works. The class Collaboration
Diagram gives three levels of abstraction showing how objects
communicate with each other. The Class Definition Diagram shows the
methods and instance variables of the class, as well as providing
the ability to browse the capabilities of the class inherited from
the class hierarchy. The Class Design Diagram allows you to design
a class similar to that of the Structured Chart with full support
of the method signature specification. These diagrams are
integrated through a project database, thereby providing multiple
views of the software design.
TurboCASE also provides intelligent help to refine the design
such as abstracting the common behaviors of classes into an
abstracted class. Subsystems can be designed top-down as well as
bottom-up by abstracting from system components. These capabilities
greatly reduce the complexities of the designs and help achieve
optimal solutions.
Audition (abstract)
Authors: Drinnan Andrew , Morton David 
Published: January 2007

This demonstration presents Audition, an object-oriented
language and environment designed to allow the easy creation of
visual and interactive programs.
It uses a metaphor of Performers and Stages, as first inspired
by the XEROX Pam Rehearsal World project. Performers are the main
interaction units. They are visible and mouse or message activated;
sample types include DisplayPerformers, Turtles, Graphs, and
Gauges. Performers are grouped on Stages; stages maintain local
name spaces so that Performers can be named and intercommunicate
using their local names. While Performers are members of a class,
they may also be specialised through the addition of
instance-specific behaviour and structure; this may also be
inherited from other performers.
Just as inheritance models is-kind-of relationships, performers
collected on a stage visibly and logically model is-part-of
relationships, in a more flexible way than instance variables. An
application is usually just a specialised stage and its specialised
performers. The performer-stage paradigm gives rise to models that
are at once well factored across their participating performers and
yet are fully encapsulated within a stage. Audition is a threaded
interpreted language implemented in itself. At present we are using
Audition to investigate planning aids and simulations for
industrial situations.
Demeter Tools/C++ (abstract)
Authors: Lieberherr Karl , Holland Ian , Hursch Walter , Silva-Lepe Ignacio , Xiao Cun 
Published: January 2007

We are demonstrating the Demeter Tools/C++, a CASE research prototype developed at Northeastern University, including the latest tools described in papers presented at ECOOP 91, ER 90, CSM 89 and OOPSLA 89 and in the Software Engineering Journal (1991).
The Demeter system has been under development since 1985 and has been regularly used and refined with support from companies such as IBM, Mettler- Toledo and SAIC.
Demeter Tools/C++ consists of the following tools:

1. Design level (programming language independent):

cddraw: to draw a class dictionary

learn: Learns class dictionary for object examples

optimize: Optimizes class dictionary

sem-check: Checks class dictionary for violations and proposes changes to the class dictionary

parse-generate, run-parser: Checks conformance between class dictionary and objects

cd-compare: Compares two class dictionaries

cd-abstract: Finds the largest class dictionary

common to both input class dictionaries

xref: Draws a graphical representation of a class dictionary

2. Generation level (C++ specific):

generate: Generates C++ class library from input class dictionary

propagate: Generates C++ member functions from propagation pattern

headers: Generate C++ function interfaces from implementation

3. Implementation level (C++ specific):

Class library of predefined member functions for object manipulation (e.g., reading, writing, drawing, accessing, etc.)
Corolla partitioning for distributed logic simulation of VLSI-circuits
Authors: Sporrer Christian , Bauer Herbert 
Published: January 2007

Time Warp has evolved to a common technique for distributed simulation. Speedup in Time Warp simulation systems mainly depends on two overhead factors: first, the load on the simulators has to be well balanced and second, communication and rollbacks have to be kept to a minimum. Both of these factors are influenced by the partitioning of the simulated system. In this paper, we focus on various static partitioning schemes used to partition digital circuits for distributed simulation.
A new hierarchical partitioning approach is presented, compared and rated with other partitioning schemes by evaluating benchmark circuits. Partitioning is done in two steps: a fine grained clustering step based on corollas and a coarse grained step forming partitions using the connectivity matrix. The corolla approach yields very good partitioning results even for a large number of partitions. The achieved speedups are almost linear (up to 12 partitions for larger circuits), as long as the partition sizes are large enough so that communication between the simulators is not a bottleneck. The results reveal the great impact of partitioning on the acceleration of distributed logic simulation and show the effectiveness of the presented corolla partitioning scheme.
Some experiments in global microcode compaction
Authors: Su B. , Ding S. 
Published: January 2007

Global microcode compaction is an open problem in firmware engineering. Although Fisher's trace scheduling method may produce significant reductions in the execution time of compacted microcode, it has some drawbacks. There have been four methods. Tree, SRDAG, ITSC , and GDDG, presented recently to mitigate those drawbacks in different ways.
The purpose of the research reported in this paper is to evaluate these new methods. In order to do this, we have tested the published algorithms on several unified microcode sequences of two real machines and compared them on the basis of the results of experiments using three criteria: time efficiency, space efficiency, and complexity.