The problems associated with open-ended group discussion are well-documented in sociology research. We seek to alleviate these issues using technology that autonomously serves as a discussion moderator. Building on top of an extensible framework called Diplomat, we develop a "conversational agent", ArbiterBot to promote efficiency, fairness, and professionalism in otherwise unstructured discussions. To evaluate the effectiveness of this agent, we recruited university students to participate in a study involving a series of prompted discussions over the Slack messenger app. The results of this study suggest that the conversational agent is effective at balancing contributions across participants, encouraging a timely consensus and promoting a higher coverage of topics. We believe that the results motivate further investigation into how conversational agents can be used to improve group discussion and cooperation.

Source code metrics have been used in past research to predict software quality and focus tasks such as code inspection. A large number of metrics have been proposed and implemented in consumer metric software, however, a smaller, more manageable subset of these metrics may be just as suitable for accomplishing specific tasks as the whole. In this research, we introduce a mathematical model for software defect counts conditioned on product metrics, along with a method for generating synthetic defect data that chooses parameters for this model to match statistics observed in empirical bug datasets. We then show how these synthetic datasets, when combined with measurements from actual software systems, can be used to demonstrate how sets of metrics perform in various scenarios. Our preliminary results suggest that a small number of source code metrics conveys similar information as a larger set, while providing evidence for the independence of traditional software metric classifications such as size and coupling.

Abstract Owing to the inherent difficulty in obtaining experimental data from wikis, past quantitative wiki research has largely focused on Wikipedia, limiting the ability to generalize such research. To facilitate the analysis of wikis other than Wikipedia, we developed WikiCrawler, a tool that automatically gathers research data from public wikis without supervision. We then built a corpus of 151 wikis, which we have made publicly available. Our analysis indicated that these wikis display signs of collaborative authorship, validating them as objects of study. We then performed an initial analysis of the corpus and discovered some similarities with Wikipedia, such as users contributing at unequal rates. We also analyzed distributions of edits across pages and users, resulting in data which can motivate or verify mathematical models of behavior on wikis. By providing data collection tools and a corpus of already‐collected data, we have completed an important first step for investigations that analyze user behavior, establish measurement baselines for wiki evaluation, and generalize Wikipedia research by testing hypotheses across many wikis.

The remote procedure call (RPC) paradigm has been a favorite of programmers who write distributed programs because RPC uses a familiar procedure call abstraction as the sole mechanism of remote operation. The abstraction helps to simplify programming tasks, but this does not mean that the resulting program's RPC-based flow of control will be anything close to ideal for high performance. The purpose of our research is to provide a source-level transformation framework as an alternative way to implement an RPC-based distributed program, so that the code can be optimized through program analysis techniques.

Many strategies for improving performance of distributed programs can be described abstractly in terms of an application's overall configuration. But previously those techniques would need to be implemented manually, and the resulting programs, though yielding good performance, are more expensive to build and much less easy to reuse. This paper describes research towards an automatic system for introducing performance improvement techniques based upon an application's configuration description.

We describe a system called POLYLITH that helps programmers prepare and interconnect mixed-language software components for execution in heterogeneous environments. POLYLITH's principal benefit is that programmers are free to implement functional requirements separately from their treatment of interfacing requirements; this means that once an application has been developed for use in one execution environment (such as a distributed network) it can be adapted for reuse in other environments (such as a shared-memory multiprocessor) by automatic techniques. This flexibility is provided without loss of performance. We accomplish this by creating a new run-time organization for software. An abstract decoupling agent, called thesoftware bus, is introduced between the system components. Heterogeneity in language and architecture is accommodated since program units are prepared to interface directly to the bus and not to other program units. Programmers specify application structure in terms of a module interconnection language (MIL); POLYLITH uses this specification to guidepackaging(static interfacing activities such as stub generation, source program adaptation, compilation, and linking). At run time, an implementation of the bus abstraction may assist in message delivery, name service, or system reconfiguration.

Dynamic reconfiguration of a distributed application is the act of changing the configuration of the application as it executes. Examples of configuration changes are replacing a software component (module), moving a module to another machine, and adding or removing a module from the application. The extension to a reconfiguration platform described automatically prepares a module for participation in reconfiguration. A machine-independent method for automatically installing this functionality in the application, given a set of reconfiguration points designated by the programmer, is presented. The focus is on the difficult problem of capturing and restoring the state of a module during a procedure call, when the activation record stack contains crucial parts of the process state.>

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

A general framework is developed for reconfiguring applications dynamically, where developers may alter the application without loss of service. After presenting the overall framework within which reconfiguration is possible, a description is given of the formal approach for programmers to capture the state of a process abstractly. An environment to support experimentation with dynamic reconfiguration is then described.>

Abstract This paper describes a language called Nimble that allows designers to declare how the actual parameters in a procedure call are to be transformed at run time. Normally, programmers must edit an application's source in order to adapt it for reuse in some new context where the interfaces fail to match exactly (e.g. the parameters may appear in a different order, data types may not exactly match, and some data may need to be either initialized or masked out when the reusable module is integrated within a new application.) But Nimble allows programmers to adapt the interfaces of existing software without having to operate on the source manually. As a result, existing software may be easily reused in a broader range of applications, and software libraries do not need to store many variants of a component that differ only in how the interfaces are used. Nimble has been implemented on a variety of Unix hosts, and is part of a broader reuse project at the University of Maryland. Our current system is suitable for use either in conjunction with existing module interconnection languages, or stand‐alone with C, Pascal and Ada source programs.

A packaging system that allows diverse software components to be easily interconnected within heterogeneous programming environments is described. Interface software and stubs are generated for programmers automatically once the programmers express their application's geometry in a few simple rules and module interconnection language attributes. By generating custom interface code for each application, based on analysis and extraction of interfacing requirements, the system is able to produce executables whose run-time performance is comparable to manually integrated applications. The system is implemented within the Unix environment.>

An environment that supports execution of programs using both N-version programming and recovery blocks in a uniform manner is described. For N-version programming, the system offers an easy and flexible way of specifying the target machines for the separate versions. The basic unit of fault tolerance supported by this system is at the procedure or function level. Each such program unit can be packaged as its own task, and different fault tolerance techniques can subsequently be employed, even within the same application. The environment also allows versions to be written in different programming languages and executed on different machines. This enhances the independence between the different versions, making the fault tolerance techniques more effective. This environment has been developed for use on Unix-based hosts and currently runs on a network of Sun and DEC workstations.>

An environment for prototyping distributed applications is described that supports different communication primitives with specified delays, and provides primitives to aid debugging and evaluation. The environment also supports heterogeneous computation in which processes can execute on different hardware. Different source languages can be used for coding different modules of the processes. The system has a centralized control and monitoring facility which is based on the Suntools window system. This approach allows users to develop distributed applications using existing languages and packages, as opposed to restricting users to using only specialized specification languages, and extends the type of work done by R. Hayes et al. (1988) by providing primitives to assist in profiling and instrumenting the applications.>

Existing computer algebra systems relieve us of having to perform tedious mathematical computations manually, thus enabling us to gain insight on the abstract problems at hand. Often these systems suggest alternate solution techniques directly. However, existing systems do little to help us manage the interactive computing environment as the scale of the problem grows: when the number of mathematical objects being studied increases, the complexity for a user to manage those objects in his environment seems to grow disproportionately. We need tools to relieve us of tedious organizational overhead every bit as much as we need the mathematical tools themselves.In response to this need, we are constructing a management assistant that works in conjunction with existing symbolic computation systems. Called Minion, it allows users to express simple plans for solving large problems in the interactive environment, and then guides the user's interaction according to that plan. Key features of this assistant are that plans are easy to construct (whether statically or during the problem solving session); the assistant helps a user visualize progress towards solving the global problem; and individual steps within a plan can be executed by arbitrary software tools, whether symbolic-, numeric- or logic-based in their implementation.Our prototype of Minion is made possible by the Polylith software interconnection system [Purt85, Purt88]. Previously we showed how Polylith's general software tool-bus based organization could help overcome the so-called 'symbolic-numeric gap' [Purt86]. Our current work with Minion takes advantage of that interconnection technology in order to focus on the management problems inherent within large scale, mathematical problem solving efforts.This paper briefly portrays the organizational problem that must be treated, and motivates the need for structure management tools in mathematical problem solving environments. We detail features of our Minion prototype that meet these needs. After a brief update on the status of our existing Polylith system, we describe how Minion is implemented using our interconnection resource.