Sign In

Communications of the ACM

121 - 130 of 174 for bentley

Flexible architectures for CSCW system support

Despite the widespread attention CSCW has received from researchers and product developers there have been very few examples of successful cooperative applications. This lack of success can be attributed in part to the lack of principles we have for CSCW system development. Identification of such principles requires a better understanding of the core functionality required to support group work. My own belief is that tools which allow developers to experiment with different strategies to support cooperation, such as alternative approaches to information sharing and presentation, update propagation, synchronisation and so on, would contribute significantly to this understanding. As such I advocate an approach to the development of cooperative systems based on prototyping, and I see this as complementary to other work focusing on discovering and articulating social interaction in order to better inform cooperative system development.Cooperative applications place novel requirements on supporting architectures, over and above those of more traditional multi-user systems. One such requirement is the need for a high degree of flexibility, necessary to support different end-users, engaged in different tasks and often adopting different methods of working. This requirement for flexibility is emphasised if we consider toolkits and environments intended to support experimentation with different strategies for managing and promoting cooperative interaction.In this brief exposition I will attempt to support my position which is based on the need for experimental prototyping of cooperative systems, and justify the claim that this prototyping requires more flexible software architectures. My thinking in this area to date has been shaped largely by experiences gained in developing the MEAD multi-user interface prototyping environment at Lancaster University. Although the MEAD system proved useful for prototyping user interfaces to support the cooperative work of air traffic controllers, it is limited in the range of cooperative interaction which can be supported. In this respect I believe MEAD is similar to most other platforms supporting development of cooperative systems.


The use of adapters to support cooperative sharing

This paper examines the importance of providing effective management of sharing in cooperative systems and argues for a specialised service to support the cooperative aspects of information sharing. The relationship between features of the cooperative shared object service and existing services is briefly examined. A number of management services of particular importance to CSCW systems are identified. The paper presents a technique of realising a shared object service by augmenting existing object facilities to provide management of their cooperative use. These facilities are realised through object adapters that provide additional cooperative facilities and greater control over the supporting infrastructure.


Situated evaluation for cooperative systems

This paper discusses an evaluation of the MEAD prototype, a multi-user interface generator tool particularly for use in the context of Air Traffic Control (ATC). The procedures we adopted took the form of opportunistic and informal evaluation sessions with small user groups, including Air Traffic Controllers (ATCOs). We argue that informal procedures are a powerful and cost effective method for dealing with specific evaluation issues in the context of CSCW but that wider issues are more problematic. Most notably, identifying the “validity” or otherwise of CSCW systems requires that the context of use be taken seriously, necessitating a fundamental re-appraisal of the concept of evaluation.


Template-driven interfaces for numerical subroutines

This paper describes a set of interfaces for numerical subroutines. Typing a short (often one-line) description allows one to solve problems in application domains including least-squares data fitting, differential equations, minimization, root finding, and integration. Our approach of “template-driven programming” makes it easy to build such an interface: a simple one takes a few hours to construct, while a few days suffice to build the most complex program we describe.


How to print floating-point numbers accurately

We present algorithms for accurately converting floating-point numbers to decimal representation. The key idea is to carry along with the computation an explicit representation of the required rounding accuracy. We begin with the simpler problem of converting fixed-point fractions. A modification of the well-known algorithm for radix-conversion of fixed-point fractions by multiplication explicitly determines when to terminate the conversion process; a variable number of digits are produced. The algorithm has these properties: No information is lost; the original fraction can be recovered from the output by rounding. No “garbage digits” are produced. The output is correctly rounded. It is never necessary to propagate carries on rounding. We then derive two algorithms for free-formal output of floating-point numbers. The first simply scales the given floating-point number to an appropriate fractional range and then applies the algorithm for fractions. This is quite fast and simple to code but has inaccuracies stemming from round-off errors and oversimplification. The second algorithm guarantees mathematical accuracy by using multiple-precision integer arithmetic and handling special cases. Both algorithms produce no more digits than necessary (intuitively, the “1.3 prints as 1.2999999” problem does not occur). Finally, we modify the free-format conversion algorithm for use in fixed-format applications. Information may be lost if the fixed format provides too few digit positions, but the output is always correctly rounded. On the other hand, no “garbage digits” are ever produced, even if the fixed format specifies too many digit positions (intuitively, the “4/3 prints as 1.333333328366279602” problem does not occur).


K-d trees for semidynamic point sets

A K-d tree represents a set of N points in K-dimensional space. Operations on a semidynamic tree may delete and undelete points, but may not insert new points. This paper shows that several operations that require &Ogr;(log N) expected time in general K-d trees may be performed in constant expected time in semidynamic trees. These operations include deletion, undeletion, nearest neighbor searching, and fixed-radius near neighbor searching (the running times of the first two are proved, while the last two are supported by experiments and heuristic arguments). Other new techniques can also be applied to general K-d trees: simple sampling reduces the time to build a tree from &Ogr;(KN log N) to &Ogr;(KN + N log N), and more advanced sampling builds a robust tree in the same time. The methods are straightforward to implement, and lead to a data structure that is significantly faster and less vulnerable to pathological inputs than ordinary K-d trees.