Programming in the large allows composition of processes executing code written using programming in the small. Traditionally, systems supporting programming in the large have included interpreters of OS command languages, but today, with the emergence of collaborative “big data” science, these systems also include cyberinfrastructures, which allow computations to be carried out on remote machines in the “cloud”. The rationale for these systems, even the traditional command interpreters, is human-centric computing, as they are designed to support quick, interactive development and execution of process workflows. Some cyberinfrastructures extend this human-centricity by also providing manipulation of visualizations of these workflows. To further increase the human-centricity of these systems, we have started a new project on cyber training - instruction in the use of command languages and visual components of cyberinfrastructures. Our objective is to provide scalable remote awareness of trainees' progress and difficulties, as well as collaborative and automatic resolution of their difficulties. Our current plan is to provide awareness based on a subway workflow metaphor, allow a trainer to collaborate with multiple trainees using a single instance of a command interpreter, and combine research in process and interaction workflows to support automatic help. These research directions can be considered an application of the general principle of integrating programming in the small and large.

This work addresses difficulty in web-supported programming. We conducted a lab study in which participants completed a programming task involving the use of the Java Swing/AWT API. We found that information about participant web accesses offered additional insight into the types of difficulties faced and how they could be detected. Difficulties that were not completely solved through web searches involved finding information on AWT/Swing tutorials, 2-D Graphics, Components, and Events, with 2-D Graphics causing the most problems. An existing algorithm to predict difficulty that mined various aspects of programming-environment actions detected more difficulties when it used an additional feature derived from the times when web pages were visited. This result is consistent with our observation that during certain difficulties, subjects had little interaction with the programming environment, they made more web visits during difficulty periods, and the new feature added information not available from features of the modified existing algorithm. The vast majority of difficulties, however, involved no web interaction and the new feature resulted in higher number of false positives, which is consistent with the high variance in web accesses during both non-difficulty and difficulty periods.

Automatic detection of programmer difficulty can help programmers receive timely assistance. Aggregate statistics are often used to evaluate difficulty detection algorithms, but this paper demonstrates that a more human-centered analysis can lead to additional insights. We have developed a novel visualization tool designed to assist researchers in improving difficulty detection algorithms. Assuming that data exists from a study in which both predicted programmer difficulties and ground truth were recorded while running an online algorithm for detecting difficulties, the tool allows researchers to interactively travel through a timeline showing the correlation between values of the features used to make predictions, difficulty predictions made by the online algorithm, and ground truth. We used the tool to improve an existing online algorithm based on a study involving the development of a GUI in Java. Episodes of difficulty predicted by the previously developed algorithm were correlated with features extracted from participant logs of interaction with the programming environment and web browser. The visualizations produced from the tool contribute to a better understanding of programmer actions during periods of difficulty, help to identify specific issues with the previous prediction algorithm, and suggest potential solutions to these issues. Thus, the information gained using this novel tool can be used to improve algorithms that help developers receive assistance at appropriate times.

Many instructors consider a programming environment replete with a large variety of interactive objects and commands a liability for teaching introductory programming. In fact, such an environment is an important pedagogical tool, whose instructional capabilities can be amplified by discovery-based programming praxes - predefined programs with embedded comments that instruct students to browse and experiment with the program code, visualize static and dynamic program state, and make inductive inferences. By embedding commentary in program code, we essentially create duals of programming lectures, which embed code in a discussion. The praxes are associated with multiple-choice quizzes, which ask students to identify the results of the experiments and the conclusions drawn from them. Students who learned using such praxes made less use of recorded lecture videos to study the material. Moreover, they received explicit instruction in several interactive features that are arguably essential to effective programming.

Named groups are persistent groups of contacts with whom a user may wish to share the same information. We have engineered a test-bed for evaluating algorithms that recommend such groups. It assumes that these algorithms first generate social graphs from email logs and then mine these graphs to recommend the lists. It supports a variety of mechanisms to gather user data to support users with different privacy needs. It can be attached to a variety of algorithms for mining the data collected. It accommodates different kinds of models for using named groups and offers an evaluation mechanism that requires no effort from the user. The test-bed also provides visualizations of the generated social graphs and generated lists. Thus, it frees algorithm designers from gathering data and evaluating and understanding the output. It has been used to evaluate and compare multiple algorithms for recommending contact groups.

In an offering of CS 1, we monitored the amount of help students in a class received through various means. We found that most students wanted help that went beyond office hours and email, and that for the vast majority of them, their grades correlated positively with the amount of help they received. However, increasing help also requires increasing instructional resources unless techniques can be found to separate the surmountable difficulties from the insurmountable ones. We have developed such a technique that looks at individual interaction logs and classifies difficulties incrementally as they occur. The insight behind the technique is that when students face surmountable difficulties, they tend to repeat certain action sequences, which can be detected to distinguish the surmountable difficulties from the insurmountable ones. A lab study shows that the mechanism gives significantly better results than the baselines.

The sending of a message raises two important questions about its response: When will the first response arrive? When will the first acceptable response arrive? These questions can be partly or completely answered by identifying distributions of response times, correlating features with response tim

Group communication abstractions provide application-level multicasting to communicate information among distributed processes. A variety of such abstractions have been provided to implement synchronous collaborative applications but they do not allow control over the multicast of information to the

Users’ contacts often need to be grouped into equivalence classes for various purposes such as easily sending a message to all members of the group. Several approaches have been recently developed to make such predictions (a) for both ephemeral and persistent groups (b) in both email and social netw

In a social network, users can sort members of their social graph into friend lists to both understand the social structures within the graph and control the flow of incoming and outgoing information. To reduce the user-effort required to create these lists, previous work has developed techniques for generating friend-lists in a static social graph. This paper considers the user effort required to create friend lists in an evolving graph. We have developed several new initial quantitative metrics to capture this effort, and identified an initial technique for modeling graph growth. We have used these metrics and model to compare two techniques for evolving friend lists when the social graph grows: manual evolution - the user evolves friend lists using no external tools -- and full recommendation -- an existing state of the art tool recommends a whole new set of friend lists. In these comparisons, we used the friend lists of 12 individuals, and simulated the growth of their social graphs and friend lists using our graph-growth model. Intuitively, when the graph evolves by a small (large) amount, the manual (automatic) approach should perform better. Our experiments show that full recommendation performs better than manual when the social graph changes by more than 1%, and yields an almost complete reduction in effort in the best cases.

Previous email prediction algorithms generate individual predictions based on the past groupings of recipients or the contents of past emails. Our work builds on this research by (a) introducing new algorithms for extending and combining previous techniques and generating hierarchical recipient pred

As distributed online communication becomes increasingly common, and audiences for live online presentations grow larger, the ability to receive meaningful feedback from audience members who are distant and distributed becomes a necessity. To this end, we have built upon previous work to create a t

A multi-domain collaboration toolkit hides heterogeneity of user-interface toolkits and associated domains from both programmers and end users of collaborative, widget-synchronizing, applications. We have developed such a system for the stand-alone, Eclipse, and web domains; and the AWT, Swing, SWT, and GWT single-user toolkits associated with these domains. Several new concepts are supported to meet these requirements including a widget server allowing a distributed widget client to manipulate widgets on an interactive device, flexible widget synchronization, flexible placement of widget listeners, "piping" centralized non-interactive replicas communicating with interactive user replicas, factory-based retargeting of the user-interface toolkit, and a new process architecture.

Two important performance metrics in collaborative systems are local and remote response times. Previous analytical and simulation work has shown that these response times depend on three important factors: processing architecture, communication architecture, and scheduling of tasks dictated by these two architectures. We show that it is possible to create a system that improves response times by dynamically adjusting these three system parameters in response to changes to collaboration parameters such as new users joining and network delays changing. We present practical approaches for collecting collaboration parameters, computing multicast overlays, applying analytical models of previous work, preserving coupling semantics during optimizations, and keeping overheads low. Simulations and experiments show that the system improves performance in practical scenarios.

A language-based direct-manipulation user-interface generator automatically creates a visualization of an object directly from its class, allows users to edit the visualization, and invokes methods in the object in response to these edits. Such a generator can change, and we argue, improve the lectures and assignments on programming conventions, methods, state, constructors, preconditions, MVC, polymorphism, graphics, structured objects, loops, concurrency, and annotations. We have built such a generator, which has several novel features for teaching such as interactive instantiation of a class, interactive invocation of methods and constructors that take arbitrary arguments, visualization of objects representing records, sequences, table and graphics, use of preconditions to disable/enable user-interface elements, and automatic generation of model threads. We have been working on and using such a generator for teaching CS 1 and CS 2 for about a decade.

The performance of a collaborative system depends on how two mandatory collaborative tasks, processing and transmission of user commands, are scheduled. We have developed multiple policies for scheduling these tasks on computers that have (a) one processing element on the network interface card and (b) one or more processing cores on the CPU. To compare these policies, we have a developed a formal analytical model that predicts their performance. It shows that the optimal scheduling policy depends on several factors including the number of cores that is available. We have implemented a system that supports all of the policies and performed experiments to validate the formal model. This system is a component of a self-optimizing scheduler we have developed that improves response times by automatically choosing the scheduling policy based on number of cores and other factors.

It would be useful if software engineers/instructors could be aware that remote team members/students are having difficulty with their programming tasks. We have developed an approach that tries to automatically create this semantic awareness based on developers' interactions with the programming environment, which is extended to log these interactions and allow the developers to train or supervise the algorithm by explicitly indicating they are having difficulty. Based on the logs of six programmers, we have found that our approach has high accuracy.

Previous research has motivated the idea of automatically determining when programmers are having difficulty, provided an initial algorithm (unimplemented in an actual system), and performed a small student-based evaluation to justify the viability of this concept. We have taken the next step in this line of research by designing and developing two-different systems that incorporate variations of the algorithm, implementing a tool that allows independent observers to code recorded sessions, and performing studies involving both student and industrial programmers. Our work shows that (a) it is possible to develop an efficient and reusable architecture for predicting programmer status, (b) the previous technique can be improved through aggregation of predicted status, (c) the improved technique correlates more with programmers' perception of whether they are stuck than that of observers manually watching the programmers, (d) the observers are quicker than the developers to conclude that programmers are stuck, (e) with appropriate training, the tool can be used to predict even the observers' perceptions, and (f) a group training model offers more accuracy than an individual one when the training and test exercises are the same and carried over a small time frame.

Facebook access-control lists, called friend lists, are difficult to create manually. Previous work on automating these lists has used friend details entered by the user. Our approach automates them by merging virtual friend cliques using certain heuristics that determine if two virtual friend cliqu

In distributed side-by-side software development, a pair of distributed team members are assigned a single task and allowed to (a) work concurrently on two different computers and (b) see each others' displays. They can control when they communicate with each other, view each others' actions, and in

A collaborative system must perform both processing and transmission tasks. We present a policy for scheduling these tasks on a single core that is inspired by studies of human perception and the real-time systems field. It lazily delays the execution of the processing task if the delay cannot be noticed by humans. We use simulations and formal analysis to compare this policy with previous scheduling policies. We show that the policy trades-off an unnoticeable degradation in performance of some users for a much larger noticeable improvement in performance of others.

Physical proximity supports various forms of ad-hoc collaboration among developers such as opportunistic task adaptation and helping co-developers when they are stuck. Connecting the input/output flows of stand-alone programming environments of distributed developers offers the potential to support such collaboration among them. Such a connection has several components including communication sessions, awareness of others' availability and the state of the objects on which they are working, and control channels allowing users to import edits of and share code with others and be notified when a team member has moved away from a program element of interest. It is possible to develop a collaboration-centered design that combines a variety of collaboration streams into a usable and useful user-interface, and implement the design using existing programming environment, communication, and compiler technologies.

Many pervasive computing systems have been built for using mobile computers to interact with networked devices. To deploy a device's user-interface, several systems dynamically generate the user-interface on a mobile computer. While this approach has several advantages, empirical results from different generators show that it takes a relatively long time for a mobile computer to create a user-interface from scratch. This paper shows that it is possible to overcome this limitation by efficiently mapping or retargeting a previously generated user-interface of one (source) device to another (target) device of the same or different type. Using the implementation of an existing generator and a set of real-world scenarios, we show that user-interface retargeting can yield deployment times that are often as good as or noticeably better than the approach of locally loading pre-existing manually-written user-interface code.

The difficult task of providing access to shared objects is, typically, carried out individually by access authorizers. We motivate and explain here the idea of using distributed collaborative environments to perform this activity. In these environments, the initiative in distributing access rights to shared objects can be taken by information guardians, information consumers, and tools that act as agents of the guardians and consumers. Information consumers are responsible for sending access requests to information guardians; their agents (partially or completely) automate this task for them. Information guardians are responsible for authorizing accesses; their agents automate this task for them. The agents interact with collaborative and communication tools, which must be extended to support the new access-control paradigm.

Some modern version-control systems automatically generate notifications as side effects of checking-in versions. We consider here the dual idea of automatically checking-in versions as side effects of manual email notification about them. This approach combines the benefits of current email, file, and version-control systems, offering a familiar and available user-interface, version management, and actor and observer control on sharing. It can be designed to (a) allow its benefits to be proportional to the degree of autonomy among the systems of various collaborators, and (b) co-exist with existing sharing approaches.

While multicast has been studied extensively in many domains such as content streaming and file sharing, there is little research applying it to synchronous collaborations involving shared access to a distributed object. Based on several cases of real-world collaborations involving instant messaging, distributed lectures, and computationally-intensive collaborative game playing, we show that compared to traditional centralized and replicated collaboration architectures, a new bi-architecture collaboration system model with multicasting support can improve response, feedthrough, and task completion times. In addition, we show that to optimize performance, the set of traditionally considered factors, consisting of network delays and transmission costs, must be expanded to include several new factors, such as processing costs, scheduling policies, and think times. In one or more of the real-world collaborations we consider, we show that multicast (a) can increase feedthrough times if processing costs and scheduling policies are not considered and (b) may degrade or improve task completion times depending on the cost of computing the multicast overlay.

One of the visions of pervasive computing is using mobile computers to interact with networked devices. A question raised by this vision is: should the user-interfaces of these devices be handcrafted manually or generated automatically? Based on experience within the domain of desktop computing, the answer seems to be that automatic generation is not flexible enough to support a significant number of useful interfaces but requires substantially less coding effort for the interfaces it can create. We show that the answer is much more complicated when we consider networking of traditional appliances such as stereos and TVs. Using qualitative arguments and quantitative experimental data, we show that the manual vs. generated issue must be resolved based on: (a) not only user-interface programming and flexibility but also several other metrics such as space and time costs, binding time, and reliability (b) whether it is a graphical or speech based user-interface, (c) the size of the device user-interface, (d) whether the manually written user-interface code is available at the mobile computer or at a remote machine, and (e) the network bandwidth between the mobile computer and remote factory

We evaluate response times, in N-user collaborations, of the popular centralized (client-server) and replicated (peer-to-peer) architectures, and a hybrid architecture in which each replica serves a cluster of nearby clients. Our work consists of definitions of aspects of these architectures that have previously been unspecified but must be resolved for the analysis, a formal evaluation model, and a set of experiments. The experiments are used to define the parameters of and validate the formal analysis. In addition, they compare the performances, under the three architectures, of existing data-centric, logic-centric, and stateless shared components. We show that under realistic conditions, a small number of users, high intra-cluster network delays, and large output processing and transmission costs favor the replicated architecture, large input size favors the centralized architecture, high inter-cluster network delays favor the hybrid architecture, and high input processing and transmission costs, low think times, asymmetric processing powers, and logic-intensive applications favor both the centralized and hybrid architectures. We use our validated formal model to make useful predictions about the performance of the three kinds of architectures under realistic scenarios we could not create in lab experiments.

The benefits of object-oriented programming apply only to programs consisting of multiple objects. Inter-object design patterns make it, in theory, possible for beginning programmers to create well-understood forms of such programs. However, their descriptions have been targeted at experienced programmers with knowledge, for instance, of the implementation of compilers. We show that it is possible to explain and motivate several of these patterns including the iterator, model-view-controller, model-interactor, observer, façade, composite, and factory patterns by showing them working "in the small" in simple examples. We have effectively used this approach to teach an undergraduate class including several college freshmen and one high-school junior, who were able to exercise the patterns "in the medium.

In this paper, we introduce the concept of dynamically changing between centralized, replicated, and hybrid collaboration architectures. It is implemented by providing users a function that dynamically changes the mapping between user-interface and program components. We decompose the function into more primitive commands that are executed autonomously by individual users. These commands require a mechanism to dynamically replicate user-interface and program components on a user's site. We present a logging approach for implementing the mechanism that records input (output) messages sent to one incarnation of a program (user-interface) component, and replays the recorded messages to a different incarnation of the component. Preliminary experiments with an implementation of the mechanism show that response and completion times can improve by dynamically changing the architecture to adapt to changes to the set of users in a collaboration session involving a mix of mobile and stationary devices.

Current application-sharing systems support a single architecture for all collaborations, though different systems support different architectures. We have developed a system that supports a wide range of architectural mappings, which include, to the best of our knowledge, all of the existing architectures defined so far including the centralized, replicated, and hybrid architectures. Instead of being bound to a specific I/O protocol such as the X protocol, it is based on a simple abstract I/O protocol to which specific I/O protocols must be mapped by client-supplied code. We have used the system to perform experiments that compare the performance of the centralized and replicated architectures. Our experiments show that the choice of the architecture depends on the computers used by the collaborators, the speed of the connections between the computers, and the cost of the operations performed by the shared application. Under some conditions the centralized architecture gives better performance, while unde r others the replicated architecture gives better performance. Our results contradict the popular belief that the replicated architecture always gives better performance, and show the need for supporting both architectures in a system.

No abstract available.

In general, collaboration infrastructures have supported sharing of an object based on its logical structure. However, current implementations assume an implicit binding between this logical structure and particular system-defined abstractions. We present a new composable design based on programming patterns that eliminates this binding, thereby increasing the range of supported objects and supporting extensibility.

Article Free Access Share on Flexible meta access-control for collaborative applications Authors: Prasun Dewan Department of Computer Science, University of North Carolina, Chapel Hill NC Department of Computer Science, University of North Carolina, Chapel Hill NCView Profile , HongHai Shen IBM Santa Teresa Lab, 555 Bailey Ave, San Jose, CA IBM Santa Teresa Lab, 555 Bailey Ave, San Jose, CAView Profile Authors Info & Claims CSCW '98: Proceedings of the 1998 ACM conference on Computer supported cooperative workNovember 1998 Pages 247–256https://doi.org/10.1145/289444.289499Published:01 November 1998Publication History 27citation672DownloadsMetricsTotal Citations27Total Downloads672Last 12 Months14Last 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

Traditionally, access control has been studied in the areas of operating systems and database management systems. With the advent of multiuser interfaces, there is a need to provide access control in the user interface. We have developed a general framework for supporting access control in multiuser interfaces. It is based on the classical notion of an access matrix, a generalized editing-based model of user-application interaction, and a flexible model of user-user coupling. It has been designed to support flexible control of all significant shared operations, high-level specification of access control policies, and automatic and efficcent implementation of access control in a multiuser interface. It supports several new kinds of protected objects including sessions, windows, and hierarchical active variables; a large set of rights including not only the traditional semantic rights but also interaction and coupling rights; a set of inference rules for deriving default permissions; and a programming interface for implementing access control in multiuser interfaces. We have implemented the framework as part of a system called Suite. This article describes and motivates the framework using the concrete example of Suite, identifies some of the difficult issues we faced in its design, describes our preliminary experience with it, and suggests directions for future work.

The author's position is fourfold: (i) collaborative applications are important, (ii) there are several complex design and implementation issues that must be resolved before such applications can become useful and commonplace, (iii) several existing disciplines partly address these issues and therefore researchers in these fields should get involved in this area, and (iv) much remains to be done before one can address the issues adequately, mainly because existing solutions have not considered humans in the loop.

No abstract available.

Goals and content: This tutorial will address the design and implementation of collaborative applications. The design space will be described using the dimensions of session management, coupling, user awareness, and undo/redo.

We have developed a new framework for supporting concurrency control in collaborative applications.It supports multiple degrees of consistency and allows users to choose concurrency control policies based on the objects they are manipulating, the tasks they are performing, and the coupling and merge policies they are using.Concurrency control policies are embodied in hierarchical, constructor-based lock compatibility tables.Entries in these tables may be specified explicitly or derived automatically from coupling and merge policies.In this paper, we motivate and describe the framework, identify several useful concurrency control policies it can support, evaluate its flexibility, and give conclusions and directions for future work.

Migrating collaborative applications to or near the workstations of active users can offer better performance in many scenarios. We have developed a client migration mechanism for centralized shared window systems that does not require changes to existing application and system software. It is based on logging input at the old site and replaying it at the new site. This approach raises several difficult questions: How should the log size be kept low? How should response time be kept low while migration is in progress? How should applications that depend on the rate at which input is received be accommodated? How should the transition from the replay phase to the play phase be detected at the new site? How should the software at the old and new sites be synchronized? We have developed a series of alternative approaches for answering these questions and implemented them in the XTV [1] shared window system. In this paper, we motivate, describe, illustrate and evaluate these approaches, an...

We have developed a new model for coupling the user interfaces of a multiuser program. It is based on an interaction model and a user interface framework that allow users and programmers, respectively, to view applications as editors of data. It consists of a semantics model, a specification model, and an implementation model for coupling. The semantics model determines (1) which properties of interaction entities created for a user are shared with corresponding interaction entities created for other users and (2) when changes made by a user to a property of an interaction entity are communicated to other users sharing it. It divides the properties of an interaction entity into multiple coupling sets and allows users to share different coupling sets independently. It supports several criteria for choosing when a change made by a user to a shared property is communicated to other users. These criteria include how structurally complete the change is, how correct it is, and the time at which it was made. The specification model determines how users specify the desired semantics of coupling. It associates interaction entities with inheritable coupling attributes, allows multiple users to specify values of these attributes, and does a runtime matching of the coupling attributes specified by different users to derive the coupling among their user interfaces. The implementation model determines how multiuser programs implement user-customizable coupling. It divides the task of implementing the coupling between system-provided modules and application programs. The modules support automatically a predefined semantics and specification model that can be extended by the programs. We have implemented the coupling model as part of a system called Suite. This paper describes and motivates the model using the concrete example of Suite, discusses how aspects of it can be implemented in other systems, compares it with related work, discusses its shortcomings, and suggests directions for future work.

The need to merge different versions of an object to a common state arises in collaborative computing due to several reasons including optimistic concurrency control, asynchronous coupling, and absence of access control. We have developed a flexible object merging framework that allows definition of the merge policy based on the particular application and the context of the collaborative activity. It performs automatic, semi-automatic, and interactive merges, supports semantics-determined merges, operates on objects with arbitrary structure and semantics, and allows fine-grained specification of merge policies. It is based on an existing collaborative applications framework and consists of a merge matrix, which defines merge functions and their parameters and allows definition of multiple merge policies, and a merge algorithm, which performs the merge based on the results computed by the merge functions. In conjunction with our framework we introduce a set of merge policies for several useful kinds of merges we have identified. This paper motivates the need for a general approach to merging, identifies some important merging issues, surveys previous research in merging, identifies a list of merge requirements, describes our merging framework and illustrates it with examples, and evaluates the framework with respect to the requirements and other research efforts in merging objects.

Abstract We have developed a new multi‐user application that integrates and extends the concepts in a variety of current multi‐user applications. It allows multiple users to store, retrieve and browse through information, communicate information both synchronously and asynchronously, create ‘pipes’ of consistent, editable and persistent views, and interactively specify handlers for events. It has been implemented using the experimental technologies of distributed objects and multi‐user editor generation. Our work on this application suggests a new and practical model for designing and implementing multi‐user applications. In this paper, we describe the user interface and implementation of the application, give the rationale for our design choices, describe our experience with the tools and techniques used in the implementation, and present conclusions and directions for future work.

Access control is an indispensable part of any information sharing system.Collaborative environments introduce new requirements for access control, which cannot be met by using existing models developed for non-collaborative domains.We have developed a new access control model for meeting these requirements, The model is based on a generalized editing model of collaboration, which assumes that usersinteract with a collaborative application by concurrently editing its data structures, It associates fine-grained data displayed by a collaborative application with a set of collaboration rights and provides programmers and users a multi-dimensional, inheritance-based scheme for specifying theserights.The collaboration rights include traditional read and write rights and severat new rights such as viewing rights and coupling rights.The inheritance-based scheme groups subjects, protected objects, and access rights; allows each component of an access specification to refer to both groups and individual members; and allows a specific accessdefinition to override a more generat one.

We have developed a high-level and flexible framework for supporting the construction of multiuser interfaces. The framework is based on a generalized editing interaction model, which allows users to view programs as active data that can be concurrently edited by multiple users. It consists of several novel components including a refinement of both the Seeheim UIMS architecture and the distributed graphics architecture that explicitly addresses multiuser interaction; the abstractions of shared active variables and interaction variables, which allow users and applications to exchange information; a set of default collaboration rules designed to keep the collaboration-awareness low in multiuser programs; and a small but powerful set of primitives for overriding these rules. The framework allows users to be dynamically added and removed from a multiuser sesssion, different users to use different user interfaces to interact with an application, the modules interacting with a particular user to execute on the local workstation, and programmers to incrementally trade automation for flexibility. We have implemented the framework as part of a system calledSuite. This paper motivates, describes, and illustrates the framework using the concrete example of Suite, discusses how it can be implemented in other kinds of systems, compares it with related work, discusses its shortcomings, and suggests directions for future work.

Article Flexible user interface coupling in a collaborative system Share on Authors: Prasun Dewan Department of Computer Sciences, Purdue University, W. Lafayette, IN Department of Computer Sciences, Purdue University, W. Lafayette, INView Profile , Rajiv Choudhard Department of Computer Sciences, Purdue University, W. Lafayette, IN Department of Computer Sciences, Purdue University, W. Lafayette, INView Profile Authors Info & Claims CHI '91: Proceedings of the SIGCHI Conference on Human Factors in Computing SystemsApril 1991 Pages 41–48https://doi.org/10.1145/108844.108851Published:01 March 1991 72citation826DownloadsMetricsTotal Citations72Total Downloads826Last 12 Months18Last 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 SiteGet Access

We have designed a set of primitives for programming multi-user interfaces by extending a set of existing high- level primitives for programming single-user interfaces.These primitives support both collaboration-transparent and collaboration-aware multi-user programs and allow existing single-user programs to be incrementally changed to corresponding multi-user programs, The collaborationaware primitives include primitives for tailoring the input and output to a user, authenticating users, executing code in a user's environment and querying and setting properties of it, and tailoring the user interface coupling.We have identified several application-independent user groups that arise in a collaborative setting and allow the original single-user calls to be targeted at these groups.In addition, we provide primitives for defining application-specific groups.Our preliminary experience with these primitives shows that they can be used to easily implement collaborative tasks of a wide range of applications including message systems, multi-user editors, computer conferencing systems, and coordination systems.In this paper, we motivate, describe, and illustrate these primitives, discuss how primitives similar to them can be offered by a variety of user interface tools, and point out future directions for work.

Abstract We have designed an inheritance model that reduces the effort required to define presentations of data structures of programs written in conventional languages. It assumes that the presentation of a data structure is determined by one or more attributes of the data structure; classifies data structures into several groups based on their types, contexts, siblings, ancestors and other properties; and allows an attribute to be defined once for all members of a group. These groups are arranged in multiple intersecting hierarchies, and a subgroup is allowed to inherit attributes from its supergroups(s). This paper motivates, describes, and illustrates our method of grouping values and arranging the value groups in inheritance hierarchies.

The authors present the query language SQL++ used in the O-Raid object-oriented database system. SQL++ is an extension to the relational query language SQL that adds object-oriented capabilities. It supports object-oriented database capabilities such as subobject referencing, method invocation, navigational queries, and 'implicit joins' while maintaining the relational capabilities and closure property of SQL. SQL++ also has an application program interface that solves the 'impedance mismatch' problem for C++ application programs, allowing them to store and retrieve objects in the database without the need to translate from one data format to another.>

Suite offers several advanced interactive features missing from contemporary interactive systems including a generic direetmanipulation user interface; a flexible input model offering benefits of both incremental and delayed feedback; customizable system-provided dialogue managers which relieve applications from managing their user interfaces; loose physical coupling between an application and its dialogue manager, that is, execution of these components in different address spaces, residing possibly on different hosts; interactive specification of customizable properities of user interfaces; and IS-A and IS-PART-OF inheritance to reduce the effort required to specify these properities.It complements recent work done in programming languages, databases, operating systems, and distributed systems.In this paper, we take the reader on a tour of the Suite user interface software, highlighting its distinguishing features.

In traditional interactive programming environments, each application individually manages its interaction with the human user. The result is duplication of effort in implementing user interface code and nonuniform—hence confusing—input conventions. This paper presents an approach to support automatic generation of user interfaces in environments based on algebraic languages. The approach supports the editing model of interaction, which allows a user to view all applications as data that can be edited. An application interacts with a user by submitting variables (of arbitrary types) to a dialogue manager , which displays their presentations to the user and offers type-directed editing of these presentations. Applications and dialogue managers communicate through a protocol that allows a presentation to be kept consistent with the variable it displays. A particular implementation of the approach, called Dost, has been constructed for the Xerox development environment and the Mesa programming language. Dost is used as a concrete example to describe the editing model, the primitives to support it, and our preliminary experience with these primitives. The approach is compared with related work, its shortcomings are discussed, and suggestions for future work are made.