This paper introduces the language-independent concept of ``thread usage policy.'' Many multi-threaded software systems contain policies that regulate associations among threads, executable code, and potentially shared state. A system, for example, may constrain which threads are permitted to execute particular code segments, usually as a means to constrain those threads from accessing or writing particular elements of state. These policies ensure properties such as state confinement or reader/writer constraints, often without recourse to locking or transaction discipline.

Object oriented frameworks impose additional burdens on programmers that libraries did not, such as requiring the programmer to understand the method callback sequence, respecting behavior constraints within these methods, and devising solutions within a constrained solution space. To overcome these burdens, we express the repeated patterns of engagement with the framework as a design fragment. We analyzed the 20 demo applets provided by Sun and created a representative catalog of design fragments of conventional best practice. By evaluating 36 applets pulled from the internet we show that these design fragments are common, many applets copied the structure of the Sun demos, and that creation of a catalog of design fragments is practical. Design fragments give programmers immediate benefit through tool-based conformance assurance and long-term benefit through expression of design intent.

We describe our system which facilitates collaboration using multiple modalities, including speech, handwriting, gestures, gaze tracking, direct manipulation, large projected touch-sensitive displays, laser pointer tracking, regular monitors with a mouse and keyboard, and wireless networked handhelds. Our system allows multiple, geographically dispersed participants to simultaneously and flexibly mix different modalities using the right interface at the right time on one or more machines. We discuss each of the modalities provided, how they were integrated in the system architecture, and how the user interface enabled one or more people to flexibly use one or more devices.

Assuring and evolving concurrent programs requires understanding the concurrency-related design decisions used in their implementation. In Java-style shared-memory programs, these decisions include which state is shared, how access to it is regulated, the roles of threads, and the policy that distinguishes desired concurrency from race conditions. These decisions rarely have purely local manifestations in code.In this paper, we use case studies from production Java code to explore the costs and benefits of a new annotation-based approach for expressing design intent. Our intent is both to assist in establishing "thread safety" attributes in code and to support tools that safely restructure code---for example, shifting critical section boundaries or splitting locks. The annotations we use express "mechanical" properties such as lock-state associations, uniqueness of references, and encapsulation of state into named aggregations. Our analyses revealed race conditions in our case study samples, drawn from open-source projects and library code.The novel technical features of this approach include (1) flexible encapsulation via aggregations of state that can cross object boundaries, (2) the association of locks with state aggregations, (3) policy descriptions for allowable method interleavings, and (4) the incremental process for inserting, validating, and exploiting annotations.

We introduce a thread colors model as a way to express design intent concerning the relationships between threads, executable code, and shared state. By expressing the model as annotations in code, it is possible to formally link the model with source code and to analyze the consistency of model and code in a composable manner. By using annotations as cut-points, APIs can be annotated and compliance with library threading policies can be evaluated. This is illustrated using case study examples from published code that show how thread coloring models can assist in assuring policy compliance and in identifying concurrency errors.

This paper presents an awareness tool designed to help distributed, asynchronous groups solve problems quickly. Using a lab study, it was found that groups that used the awareness tool tended to converge and agree upon a solution more quickly. However, it was also found that individuals who did not use the awareness tool got closer to the correct solution. Implications for the design of awareness tools are discussed, with particular attention paid to the importance of matching the features of an awareness tool with a workgroup's tasks and goals.

Article Communication and information: alternative uses of the Internet in households Share on Authors: Robert Kraut Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PAView Profile , Tridas Mukhopadhyay Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PAView Profile , Janusz Szczypula Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PAView Profile , Sara Kiesler Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PAView Profile , William Scherlis Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, 5000 Forbes Avenue, Carnegie Mellon University, Pittsburgh, PAView Profile Authors Info & Claims CHI '98: Proceedings of the SIGCHI Conference on Human Factors in Computing SystemsJanuary 1998 Pages 368–375https://doi.org/10.1145/274644.274695Online:01 January 1998Publication History 32citation2,409DownloadsMetricsTotal Citations32Total Downloads2,409Last 12 Months35Last 6 weeks4 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

The god of this paper is to iden@ the communication tactics that tiow management teams to successtiy coordinate without becoming overloaded, and to see whether successti coordination and fidom from overload independently Muence team pefiormance.We found that how much teams comnumicatti, what they communicated abou~and the technologies they used to communicate prdlcted coordination and overload.Team coordination but not overload prdlcted team SUWSS.

Structural change in a large system is hindered when information is missing about portions of the system, as is often the case in a distributed development process. An annotation mechanism called promises is described for expressing properties that can enable many kinds of structural change in systems. Promises act as surrogates for an actual component, and thus are analogous to "header" files, but with more specific semantic information. Unlike formal specifications, however, promises are designed to be easily extracted from systems and managed by programmers using automatic analysis tools. Promises are described for effects, unique references, and use properties. By using promises, a component developer can offer additional opportunity for change (flexibility) to clients, but at a potential cost in flexibility for the component itself. This suggests the possibility of using promises as a means to allocate flexibility among the components of a system.

No abstract available.

Article Free Access Share on HomeNet: a field trial of residential Internet services Authors: Robert Kraut Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PAView Profile , William Scherlis Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PAView Profile , Tridas Mukhopadhyay Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PAView Profile , Jane Manning Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PAView Profile , Sara Kiesler Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PA Human Computer Interaction Institute, Carnegie Mellon University, Pittsburgh, PAView Profile Authors Info & Claims CHI '96: Proceedings of the SIGCHI Conference on Human Factors in Computing SystemsApril 1996 Pages 284–291https://doi.org/10.1145/238386.238531Published:13 April 1996Publication History 30citation1,769DownloadsMetricsTotal Citations30Total Downloads1,769Last 12 Months132Last 6 weeks9 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteView all FormatsPDF

article Free Access Share on Object-oriented megaprogramming (panel) Authors: Peter Wegner View Profile , William Scherlis View Profile , James Purtilo View Profile , David Luckham View Profile , Ralph Johnson View Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 27Issue 10Oct. 1992 pp 392–396https://doi.org/10.1145/141937.141968Published:31 October 1992Publication History 1citation258DownloadsMetricsTotal Citations1Total Downloads258Last 12 Months9Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Computations can generally be separated into stages, which are distinguished from one another by either frequency of execution or availability of data. Precomputation and frequency reduction involve moving computation among a collection of stages so that work is done as early as possible (so less time is required in later steps) and as infrequently as possible (to reduce overall time).We present, by means of examples, several general transformation techniques for carrying out precomputation transformations. We illustrate the techniques by deriving fragments of simple compilers from interpreters, including an example of Prolog compilation, but the techniques are applicable in a broad range of circumstances. Our aim is to demonstrate how perspicuous accounts of precomputation and frequency reduction can be given for a wide range of applications using a small number of relatively straightforward techniques.Related work in partial evaluation, semantically directed compilation, and compiler optimization is discussed.

We investigate the specialization of programs by means of program transformation techniques. There are two goals of this investigation: the construction of program synthesis tools, and a better understanding of the development of algorithms.By extending an ordinary language of recursion equations to include a generalized procedure construct (the expression procedure), our ability to manipulate programs in that language is greatly enhanced. The expression procedure provides a means of expressing information not just about the properties of individual program elements, but also about the way they relate to each other.A set of four operations for transforming programs in this extended language is presented. These operations, unlike the transformation rules of Burstall and Darlington and of Manna and Waldinger, preserve the strong equivalence of programs.This set of operations forms the basis of a general-purpose specialization technique for recursive programs. The practical value of this technique has been demonstrated in the systematic development of many programs, including several context-free parsing algorithms. We outline here the development of Earley's algorithm by specialization.This paper is an informal exposition of part of the results of the author's Ph.D. thesis [Scherlis80].