bluuebunny/crossref_metadata_2025_split huggingface dataset:
Prompting, feedback and error correction in the design of a scenario machine
Authors: Carroll John M. , Kay Dana S. 
Published: January 2007

The recent technical literature abounds with a variety of studies documenting and analyzing the problems people encounter in learning to use contemporary computer equipment. This has been a major focus of the recent work in our laboratory ([6], [9]). The project such work must entrain is the development of design approaches to these problems. We have been and are developing alternate designs for training manuals and for in-system training ([2], [4], [5], [7]).
This paper is a report of work in progress in this area. We describe a design approach to in-system training referred to as the Scenario Machine, and describe some initial results from an empirical learning study of four scenario machines.
Event-response systems
Authors: Hill Ralph D. 
Published: January 2007

Event-Response Systems are a technique for specifying the syntax of multi-threaded dialogues. They are based on the paradigm of specifying system responses to events generated by the user. They can compactly represent the concurrency needed to implement multi-threaded dialogues. This concurrency support also allows interfaces to be structured differently than is possible with existing dialogue specification systems based on state transition specifications or grammars. This flexibility allows many interfaces, especially direct manipulation interfaces, to be specified with a more modular structure than most existing systems allow.
Event-Response Systems are described formally, and a dialogue specification language based on the ERS formalism is informally presented. Some example uses and implementation techniques are also described.
Notecards in a nutshell
Authors: Halasz Frank G. , Moran Thomas P. , Trigg Randall H. 
Published: January 2007

NoteCards is an extensible environment designed to help people formulate, structure, compare, and manage ideas. NoteCards provides the user with a “semantic network” of electronic notecards interconnected by typed links. The system provides tools to organize, manage, and display the structure of the network, as well as a set of methods and protocols for creating programs to manipulate the information in the network. NoteCards is currently being used by more than 50 people engaged in idea processing tasks ranging from writing research papers through designing parts for photocopiers.
In this paper we briefly describe NoteCards and the conceptualization of idea processing tasks that underlies its design. We then describe the NoteCards user community and several prototypical NoteCards applications. Finally, we discuss what we have learned about the system's strengths and weaknesses from our observations of the NoteCards user community.
The CTalk programming language
Authors: Girardot Jean-Jacques 
Published: January 2007

This document presents
CTalk
, which is a new programming language quite different from APL itself. CTalk is an attempt to combine the “best” features of APL, but also of other languages such as Lisp [9], and offer a language that looks “satisfactory” according to the criteria of the mainstream of computer science.

The most important features of CTalk are its syntax, which is very close to the one of the C programming language, the adoption of fundamental concepts that were missing in APL, such as lexical binding, but also the integration of a wide range of array operations that are borrowed from APL.
It is shown here that CTalk can be implemented more simply and more efficiently than APL, while keeping all the power of APL operations, and being an acceptable alternative to APL itself.
WSDM
Authors: Surkan Alvin J. 
Published: January 2007

A functional style application of APL notation succinctly describes the architecture and principles of operation of one kind of connection-based computer. In the future it is expected that these machines will have thousands of processors and large arrays of dynamic connections. APL programs running on von Neumann computers now provide precise descriptions of connection-based machines which are convenient for exploring the potential of connection-based computation. Experience with radically new structures and different principles of operation for neural network problem solving can be obtained using virtual machines provided by software. Virtual machines are described by functions programmed on conventional computers.
Two adaptive variants of the sparse distributed memory or SDM (Kanerva [1991]) show improved efficiency. The demonstrated superiority of Kanerva's new pattern weighting idea can be obtained by improved coding of the input patterns. This coding is done by generally defined preprocessing of features of representative binary input patterns. Transformed input patterns select addresses which pack distributed memories more efficiently.
Coding is done by first computing customized weight vectors for each input pattern vector. Individual weighting of each pattern leads to more uniform utilization of the addresses and their corresponding memory connection weights. The derived pattern weights improve discrimination between pairs of similar inputs with few significant differences. This paper is to provide the APL community access to a concise symbolic description of Kanerva's weighted SDM machine. APL's rich set of computer modeling and exposition tools have the potential of markedly accelerating software and hardware development for array-base connectionist computing.
Iterative development/OO
Authors: Coplien J. O. , Hutz Susana , Marykuca Brent 
Published: January 2007

A combined workshop drawing on the faculties of the established “The Bottom Line: Using Object-Oriented Development in the Commercial Environment” workshop and the new “Development Processes for Use of the Object Paradigm” covered issues of process, architecture, and tool support for iterative development. Keynote talks described:
Discussion on architecture, tools and reuse, and management techniques followed. Key areas of consensus included the multidimensionality of architecture, the inadequacy of class models alone to encapsulate change, the importance of tool support, and the need for local standards such as “software backplanes.”
Types for the working programmer (abstract)
Authors: Black Andrew 
Published: January 2007

There has been recent progress in understanding types for object-oriented languages, but most of it has had little or no impact on real programmers. This tutorial aims to extract from the confusion those topics that are important to programmers who must use or choose an object-oriented language. The tutorial explains the role of types in object-oriented languages, what types can do for programmers, and how the trend towards distributed and heterogeneous systems and object-oriented databases influences what it means for a program to be type-correct.
The tutorial describes the difference between objects and values, what types are and why they are good for you, what refinement and subtyping are, what problems they solve, and what problems they do not; why contravariance isnt an unnatural act; why inheritance is a relationship between programs, not between classes.
By the end of the tutorial, you will understand how abstract concepts like subtyping can help you solve practical problems such as deciding when one piece of code can be substituted for another.
Advanced CLOS and meta-object protocols (abstract)
Authors: White Jon L. 
Published: January 2007

One of the important characteristics of CLOS is its dynamic flexibility to change descriptions, programs, and even data objects on the fly. A typical CLOS system is implemented by a set of meta-objects, which can be changed by the programmer, essentially letting you create a new language. Thus, CLOS is a reflective programming language.
The main purpose of this tutorial is to teach you how to put a meta-object protocol to a practical use. In addition to describing the implementation of a typical CLOS system and discussing the various issues raised by the book Art of the Meta-Object Protocol, it gives practical examples of meta-object extensions including techniques for making user-defined metaclasses, for making alternations to SLOT-VALUE so that certain slots can be persistent, and for making metaclasses whose classes automatically keep a table of all their instances.
The tutorial is aimed at the CLOS programmer or the programming language expert who would like to learn more about reflective programming using a meta-object protocol. The emphasis is on practical uses of a meta-object protocol, not on the philosophy of reflection.
Introduction to object-oriented database management systems (abstract)
Authors: Maier David 
Published: January 2007

This tutorial begins by explaining object-oriented database management systems (OODBMS) in terms of what is the value added beyond record-oriented database systems and object-oriented programming languages. It presents most of the current commercial OODBMS and several advanced prototypes with particular attention to distinguishing them in their data models, application interfaces and system architectures. It will also contrast the OODBMS approach with extended relational systems. A goal of the tutorial is to give participants an appreciation for the consequences of design choices made in the different systems. It concludes with a critique of current market offerings, and suggests there are significant regions of the design space to explore, and needs of advanced applications that are still largely unmet by any database product.
This tutorial is designed both for those considering investing in OODBs and those who just want to understand the technology. It assumes knowledge of object-oriented programming concepts, and some familiarity with conventional database systems, particularly relational databases.
Evaluating reusable class libraries (abstract)
Authors: Korson Timothy 
Published: January 2007

Object-oriented technology not only affects the way we design individual applications, it holds the potential of ushering in the software industrial revolution. A key to the success of object technology is the widespread availability of high quality class libraries. These class libraries are the re-usable parts of the software industry.
This tutorial teaches how to evaluate object-oriented libraries. The same criteria can be used for selecting commercial libraries or for designing libraries for use in-house. The tutorial also describes practical criteria for specifying and cataloging in-house corporate software libraries. In addition to these technical criteria, the tutorial also shows you the corporate infrastructure that is necessary for enabling large scale reuse.
Object engineering (abstract)
Authors: Ballard R. Stonewall 
Published: January 2007

Converting an object-oriented design into class definitions in an object-oriented language often requires many engineering decisions. It is easy to make these decisions incorrectly for languages that give the programmer a lot of control over data representation, such as C++. This tutorial covers low-level issues in building extensible and evolvable programs, issues that are important if you want to build well-balanced abstractions. It describes how to use multiple inheritance properly in spite of the compiler, when to use forwarding instead of inheritance, how to encapsulate state, and when to use references instead of copying objects.
This tutorial teaches how to convert object-oriented designs into code that is easy to extend and reuse. Many of the issues are more interesting to C++ programmers than Smalltalk programmers, and C++ is the language used for examples, but most of the issues are language independent.
Teaching object-oriented programming and design (abstract)
Authors: McKim James C. 
Published: January 2007

A course in object-oriented programming and design oriented paradigm, namely that it promotes reuse, should address the claims made for the object- models the problem space, facilitates maintenance, incorporates changes easily, and shortens the development lifecycle. One way (perhaps the only way) for students to test such claims is to build a small but high quality product as part of the course.
This tutorial shows how to have students in a conventional computer science program build such a product, and addresses such issues as how to pick good projects, whether and how students should work together in teams, how to keep students on schedule, and how to divide a project into a sequence of deliverables within the context of a one semester course.
The tutorial also describes how to scale back the approach so that students in short courses, common in industry, can get maximum benefit in the limited time that is allowed.
A case study of domain analysis
Authors: Fowler Martin , Cairns Thomas 
Published: January 2007

Three years ago the UK National Health Service decided to develop a generic model to describe all aspects of its management and operation. Several projects were launched to describe the health care process using the object-oriented modeling technique Ptech (now published by James Martin and Jim Odell). One of these projects, the Cosmos project, produced the Cosmos Clinical Process Model (or CCPM), which describes the medical record. The CCPM contains approximately 70 object types in a highly abstract structure describing clinical procedures, observations, evidence and assessment, accountabilities and contracts, care planning, and clinical knowledge. The model has gained widespread interest in both the UK and Europe and will be used as the focus for a number of EEC sponsored projects, and is taking a leading standardization role in Europe.
The CCPM is an example of the result of domain analysis. Its use of abstractions, some of which are applicable outside health care, and its use of an operational/knowledge divide can guide those working on large-scale generic models in other areas. The tutorial describes the relationship between generic and specific models since these issues are key in the acceptance of a highly generic application area model by those with specific applications to develop. The question of adapting an object-oriented method for particular needs is also addressed.
Constraint-based languages and systems (abstract)
Authors: Freeman-Benson Bjorn , Boming Alan 
Published: January 2007

A constraint is a relation that should be satisfied, for example, that a line remain horizontal, that a resistor in an electrical circuit simulation obey Ohms Law, or that the height of a bar in a bar chart be proportional to some number in an application program. Constraints have been used in a variety of languages and systems, particularly in user interface tool kits, in planning and scheduling, and in simulation. They provide an intuitive declarative style of programming that integrates well with object-oriented systems.
This tutorial teaches what constraints are, how to use them in applications such as user interfaces, how to implement them (including how to implement constraint hierarchies), and how to embed them in object-oriented and logic programming languages. You dont have to know anything about constraints, but it would be helpful to have a strong background in programming languages.
Object-oriented geometry and graphics (abstract)
Authors: Krc-Jediny Jan , Mrazik Augustin 
Published: January 2007

Spatial information is an important part of geographic information systems, CAD and CAM systems, and user interfaces for visualization of any kind of information. The object-oriented approach to spatial object modelling results in much more understandable designs than non-object-oriented approaches.
This tutorial describes the design of several key components of a system for dealing with spatial information which are: analytical geometry closed with respect to union, intersection and complement operations; hierarchically structured objects for maintaining topological information; object identity and problems arising from change of spatial objects in the database and user interface, transactions and copies of objects; dependencies of spatial objects and their copies in the MVC user-interface architecture.
You should have experience in building user-interfaces and should have some background in analytical geometry. Examples are shown in Smalltalk, so a basic knowledge of Smalltalk would be helpful.
Composition based object-oriented software development (COOSD) methodology and supporting tools (abstract)
Authors: Bosch Jan 
Published: January 2007

At the University of Twente, the Netherlands, we have been
developing methods and techniques in the area of object oriented
analysis and design. Our major contribution is the so-called
Composition Based Object Oriented Software Development (COOSD)
methodology, which includes methods, computational models, and
supporting tools. We have applied this methodology in about 20
pilot studies and we have been organizing tutorials in Europe.
The supporting tools, organized in an Integrated CASE tool
environment, support the developer both in the analysis and in the
design process, whereafter automatic translation of the design,
described in a high-level object oriented language, called SINA, to
C++ is offered.
HotDraw (abstract)
Authors: Johnson Ralph 
Published: January 2007

HotDraw is a framework for structured drawing editors that has
been floating around the Smalltalk community for several years
under several incarnations. It was originally developed by Kent
Beck and Ward Cunningham, but has been reimplemented many times
since then. Most of these implementations were proprietary. Our
design extends the original one by making constraints more
composable and by adding metafigures, but the system is instantly
recognizable by anyone familiar with one of the earlier
implementations.
We wrote a version of HotDraw for ObjectWorks\Smalltalk Release
4.0 that we are distributing. We will describe and demonstrate the
basic framework and several applications built from it, such as a
visual programming language, a tool for inspecting Smalltalk
objects by drawing pictures of them, an environment for learning
Smalltalk by issuing commands and writing scripts for visible
objects, and a PERT chart editor. These applications illustrate
several advanced Smalltalk techniques, such as light-weight
classes, compiling code on the fly, and dynamically redirecting
messages by overriding doesNotUnderstand:. Time permitting, well
explore the implementation of HotDraw and how it uses these
techniques.
Restructuring a parallel simulation to improve cache behavior in a shared-memory multiprocessor
Authors: Cheriton David R. , Goosen Hendrik A. , Holbrook Hugh , Machanick Philip 
Published: January 2007

Synchronization is a significant cost in many parallel programs, and can be a major bottleneck if it is handled in a centralized fashion using traditional shared-memory constructs such as barriers. In a parallel time-stepped simulation, the use of global synchronization primitives limits scalability, increases the sensitivity to load imbalance, and reduces the potential for exploiting locality to improve cache behavior.
This paper presents the results of an initial one-application study quantifying the costs and performance benefits of distributed, nearest neighbors synchronization. The application studied, MP3D, is a particle-based wind tunnel simulation. Our results for this one application on current shared-memory multiprocessors show a significant decrease in synchronization time using these techniques. We prototyped an application-independent library that implements distributed synchronization. The library allows a variety of parallel simulations to exploit these techniques without increasing the application programming beyond that of conventional approaches.
A quantitative analysis of cache policies for scalable network file systems
Authors: Dahlin Michael D. , Mather Clifford J. , Wang Randolph Y. , Anderson Thomas E. , Patterson David A. 
Published: January 2007

Current network file system protocols rely heavily on a central server to coordinate file activity among client workstations. This central server can become a bottleneck that limits scalability for environments with large numbers of clients. In central server systems such as NFS and AFS, all client writes, cache misses, and coherence messages are handled by the server. To keep up with this workload, expensive server machines are needed, configured with high-performance CPUs, memory systems, and I/O channels. Since the server stores all data, it must be physically capable of connecting to many disks. This reliance on a central server also makes current systems inappropriate for wide area network use where the network bandwidth to the server may be limited.
In this paper, we investigate the quantitative performance effect of moving as many of the server responsibilities as possible to client workstations to reduce the need for high-performance server machines. We have devised a cache protocol in which all data reside on clients and all data transfers proceed directly from client to client. The server is used only to coordinate these data transfers. This protocol is being incorporated as part of our experimental file system, xFS. We present results from a trace-driven simulation study of the protocol using traces from a 237 client NFS installation. We find that the xFS protocol reduces server load by more than a factor of six compared to AFS without significantly affecting response time or file availability.
STEP development tools: METASTEP language system
Authors: Wilburn D. L. , Schleimer S. 
Published: January 2007

STEP Development Tools (SDT) is a general-purpose microprogram development system. The METASTEP language system is composed of four tools of the SDT needed to write microprograms: a Definition Processor, a Retargetable Assembler, a Retargetable Cross-Assembler, and a Relocatable Linker.
These tools are of commercial quality, providing complete languages, quality diagnostics, full interface to other support tools, and high performance. The language system supports microcode debug by providing complete run-time information and by interacting directly with other debug tools provided in SDT.
Geometric data of cross-sections of beams
Authors: Besier Holger 
Published: January 2007

This paper describes a program which calculates the geometrical characteristic values of cross-sections of beams with complex shapes (bars or thin-walled profiles with any number of holes in the profiles).
After a short introduction describing the calculations involved for moments of area, we will introduce the capabilities of every component of this program and we will make a survey of the whole system via flow chart.
At the end of the paper we will summarize the main features of the program and mention some possible extensions.
A new graphical user interface proposal for APL
Authors: Bowman Dick 
Published: January 2007

In the past APL had two significant advantages over many other problem-solving computational tools. The first of these was that the language elements of APL have a consistency and breadth that remains unchallenged, at least for the tasks for which they were designed. The other historic advantage of APL, that it provided an interactive problem-solving environment, has long since been eroded. Indeed, we have seen a transformation of some programming languages into programming environments.
The purpose of this paper is to explore some possible ways in which the face that APL presents to those who program with it could usefully be enhanced.