waashk/acm huggingface dataset:
interactive blackbox debugging for concurrent languages  we describe a novel approach to the design of portable integrated debugging tools for concurrent languages. our design partitions the tools set into two categories. the language specific tools take into account the particular features of a programming language for on-line experimenting with and monitoring of distributed programs. the language independent tools support off-line presentation and analysis of the monitored information. the separation of the language independent tools from the language specific tools allows adapting the tools to support debugging for a broad category of concurrent programming languages. the separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. we present an overview of our design and describe the implementation of a prototype debugging facility for occam.  g. goldszmidt s. katz s. yemini
extending compound assignments for c++  compound assignments have been created with efficiency, for handling a subset of things that simple assignments can do. this gain in efficiency is due to the interpretation of the compound assignment as a message that modifies self ("this"). however, c++ does not extend the same interpretation of compound assignments to user defined types. in this paper, we illustrate how the notion of compound assignments is natural in c++, how it can be implemented and indicate that the resulting gain in efficiency is akin to the gain in efficiency obtained by optimizing c compilers that translate complex expressions to simple ones that use compound assignments.  t. b. dinesh
the benefits of bottom-up design  this paper examines an inconsistency in generic 'top-down' design meth ods and standards employed in the implementation of reliable software. many design approaches adopt top-down ordering when defining the structure, interfaces, and processing of a system. however, strict adherence to a top-down sequencing does not permit accurate description of a system's error handling functions. the design of a system's response to errors is becoming critical as the reliability requirements of systems increase. this paper describes how top- down methods such as object oriented design and structured design do not adequately address the issues of error handling, and suggests using a bottom- up substep within these methods to eliminate the problem.  gregory mcfarland
a graph based architectural (re)configuration language for several different reasons, such as changes in the business or technological environment, the configuration of a system may need to evolve during execution. support for such evolution can be conceived in terms of a language for specifying the dynamic reconfiguration of systems. in this paper, continuing our work on the development of a formal platform for architectural design, we present a high- level language to describe architectures and for operating changes over a configuration (i.e., an architecture instance), such as adding, removing or substituting components or interconnectons. the language follows an imperative style and builds on a semantic domain established in previous work. therein, we model architectures through categorical diagrams and dynamic reconfiguration through algebraic graph rewriting. michel wermelinger antónia lopes jose luiz fiadeiro
application screen management: an apl2 approach  this paper describes a comprehensive full screen management system written in apl2. it provides an application i/o interface that may be adapted to a variety of screen management specific subsystems in both interactive and background environments. besides the usual character and numeric field support, additional field types and attributes are supported by the system described here.  this system differs from past efforts in several respects. it is written in apl2, and takes full advantage of apl2's extended data structures and vector notation for its implementation and application code interfaces. additionally, it was designed as a generalized application- user i/o interface, and as such, provides a great deal of isolation between the application and the specific screen management subsystem employed by the screen functions. it is also easily extended to support new features, such as additional field types, as well as new screen management subsystem specific facilities as they become available. to date, such extensions have been made without impacting the existing application base. in actual application usage, these functions have been found to be easy to use, and have in most instances resulted in simpler application code than would have been possible otherwise.  stephen deerhake
using idle workstations in a shared computing environment  the butler system is a set of programs running on andrew workstations at cmu that give users access to idle workstations. current andrew users use the system over 300 times per day. this paper describes the implementation of the butler system and tells of our experience in using it. in addition, it describes an application of the system known as gypsy servers, which allow network server programs to be run on idle workstations instead of using dedicated server machines.  d. nichols
scheduling periodic time-critical tasks on a multiprocessor system (abstract only)  we study the problem of scheduling periodic-time-critical tasks on a multiprocessor system. a periodic-time-critical task consists of a certain number of computations, each arising at a fixed interval of time, called the period of the task. the ratio of the computation time to the period is called the utilization factor of the task. each computation has a prescribed deadline which must be guaranteed to be met, failing which there is likely to result an irrepairable loss. the scheduling problem is to specify the processor on which a computation is to be made and the order in which such computations will be made, such that every computation meets its deadline. the goal is to minimize the number of processors needed. the problem is np- complete. as such, we devise a heuristic algorithm and analyze its performance. the algorithm assigns tasks based on the utilization factors of the tasks. we analyze the worst case performance of the algorithm by obtaining bounds on the ratio of the maximum number of processors needed by the algorithm to the minimum number of processors required. it is shown that this ratio is 2.  s. k. dhall s. davari-hadikiashari
an approach to software design documentation  this paper presents an approach to developing system design documentation and then programming the software code directly into the specifications. an introduction to the purpose and content of design documentation is given, along with a description of current practices which are used in the development process.  it is recommended that the documents be developed using automated methods. the code is then implemented directly into the files containing the specifications.  these techniques should result in better configuration management and control of software changes. it is more likely that the specifications will be kept current throughout the life cycle of the system. the documentation should be more useful to the maintenance software engineer. the methods should be less costly compared to current techniques.  mike burlakoff
two issues in parallel language design  in this article, we discuss two programming language features that have value for expressibility and efficiency: nonstrictness and nondeterminism. our work arose while assessing ways to enhance a currently successful language, sisal [mcgraw et al. 1985]. the questions of how best to include these features, if at all, has led not to conclusions but to an impetus to explore the answers in an objective way. we will retain strictness for efficiency reasons and explore the limits it may impose, and we will experiment with a carefully controlled form of nondeterminism to assess its expressive power.  a. p. w. böhm r. r. oldehoeft
porting apl-programs via ascii-transliteration  a scheme for translating apl characters to ascii text is introduced, and an apl application is developed which reads and writes objects to and from files using the scheme. the system is available freely for several apl dialects; it can be used to port apl applications across different environments. the translation scheme used is proposed as a standard for the ascii representation of apl characters, and feedback on this scheme is invited.  johann mitlöhner
design of a distributed implementation of abcl/i  in this paper we describe the design decisions leading to a distributed implementation of the abcl language. we shortly review the abcl (actor based concurrent language) computation model. we discuss some slight changes we bring to the current abcl/1 language in order to distribute objects among several machines. identification, reference, allocation and communication are the four concepts which need some evolution. the status of a first prototype implementation on a network of workstations (lisp/suns+ethernet) is reported.  j.-p. briot j. de ratuld
mesa from the perspective of a designer turned user  the mesa language and run-time environment were designed for the purpose of building systems programs such as compilers, operating systems, graphics software and so on. it is a relatively high-level language with strong type checking and supports the ideas of modular programming and abstract data types. although the system is compiler-based, one can debug programs interactively in source-language terms.  the language has been in rather heavy use since 1976 by a programming community of a few hundreds of professional programmers within the xerox corporation, and a large amount of code has been written in it. this talk will give a designer's retrospective view of mesa from the vantage point of a serious user and will attempt to evaluate its strengths and weaknesses as a vehicle for systems programming.  james g. mitchell
model checking java programs  automatic state exploration tools (model checkers) have had some success when applied to protocols and hardware designs, but there are fewer success stories about software. this is unfortunate, since the software problem is worsening even faster than the hardware and protocol problems. model checking of concurrent programs is especially interesting, because they are notoriously difficult to test, analyze, and debug by other methods.  this talk will be a description of our initial efforts to check java programs using a model checker. the model checker supports dynamic allocation, thread creation, and recursive procedures (features that are not necessary for hardware verification), and has some special optimizations and checks tailored to multi-threaded java program. i will also discuss some of the challenges for future efforts in this area.  david dill
test and analysis of software architectures some dod programs now require prospective contractors to demonstrate the superiority of their software architectures for new weapons systems. this acquisition policy provides new software engineering challenges that focus heavily on the test and analysis of software architectures in order to determine the "best" architecture in terms of its implementability, affordability, extendability, scalability, adaptability, and maintainability --- not overlooking whether or not it will meet the functional requirements of the system. will tracz
dynamic typing for distributed programming in polymorphic languages  while static typing is widely accepted as being necessary for secure program execution, dynamic typing is also viewed as being essential in some applications, particularly for distributed programming environments. dynamics have been proposed as a language construct for dynamic typing, based on experience with languages such as clu, cedar/mesa, and modula-3. however proposals for incorporating dynamic typing into languages with parametric polymorphism have serious shortcomings. a new approach is presented to extending polymorphic lnanguages with dynamic typing. at the heart of the approach is the use of dynamic type dispatch, where polymorphic functions may analyze the structure of their type arguments. this approach solves several open problems with the traditional approach to adding dynamic typing to polymorphic languages. an explicity typed language xmldyn is presented; this language uses refinement kinds to ensure that dynamic type dispatch does not fail at run-time. safe dynamics are a new form of dynamics that use refinement kinds to statically check the use of run-time dynamic typing. run-time errors are isolated to a separate construct for performing run-time type checks  dominic duggan
in-house documentation in a small college  canisius college is a private, jesuit college with about 2,500 day students and 2,000 evening students. there is one computer center serving both academic and administrative needs with a staff of 19 people. as a functional unit within the computer center, user services consists of a manager, two programmer analysts, and a documentation librarian. we are responsible for three supervised public computing sites; an apple lab, an ibm lab, and the main computing lab which contains apples, ibm pcs and vax terminals. there are two non-staffed public computing sites containing vax terminals. to staff the labs, there is a minimum of 10 student consultants and about 35 site operators reporting to the public site coordinator, a graduate assistant position usually filled by an mba student.  the staff of user services supports instructional and research computing as well as administrative uses of microcomputers. we don't have the luxury to specialize in a particular type of computer, software, or user. each of us needs to be familiar with much of the supported software and be ready to answer those quick questions from a variety of sources. often, a well-written handout is the fastest and most effective way of doing this. a well-written handout is one you give to a person and you don't see that person again to explain the handout. this paper will describe the methods by which we develop, catalogue, and distribute what are hopefully well-written handouts.  documentation can be formal or informal. we are all familiar with the following scenario. someone asks you a question. you go through the procedure with them and accomplish the task at hand. but for that person to perform this procedure on their own, the next day or a few months from now, what was done needs to be written down or, if appropriate, pointed out in the manual. the most accurate instructions are written as you work through the procedure, not after the procedure is done.  but every question and every procedure can not become a formal document. so what should be documented? obviously, handouts that address frequently asked questions are worthwhile and handouts that introduce new capabilities or methods to the user are valuable. start with the application packages that are in heaviest use on your campus.  the most common type of document is designed to get a person started on a software package. it provides the basics: how to start up the package, how to enter information, how to load, save and print the document or file. it does not cover more advanced topics  mark castner cathy bacon
composition patterns: an approach to designing reusable aspects  requirements such as distribution or tracing have an impact on multiple classes in a system. they are _cross-cutting_ requirements, or _aspects_. their support is, by necessity, scattered across those multiple classes. a look at an individual class may also show support for cross-cutting requirements tangled up with the core responsibilities of that class. scattering and tangling make object-oriented software difficult to understand, extend and reuse. though design is an important activity within the software lifecycle with well-documented benefits, those benefits are reduced when cross-cutting requirements are present. this paper presents a means to mitigate these problems by separating the design of cross-cutting requirements into _composition patterns_. composition patterns require extensions to the uml, and are based on a combination of the subject-oriented model for composing separate, overlapping designs, and uml templates. this paper also demonstrates how composition patterns map to one programming model that provides a solution for separation of cross-cutting requirements in code--- aspect-oriented programming. this mapping serves to illustrate that separation of aspects may be maintained throughout the software lifecycle.  siobhán clarke robert j. walker
optimizing parallel programs with explicit synchronization  we present compiler analyses and optimizations for explicitly parallel programs that communicate through a shared address space. any type of code motion on explicitly parallel programs requires a new kind of analysis to ensure that operations reordered on one processor cannot be observed by another. the analysis, based on work by shasha and snir, checks for cycles among interfering accesses. we improve the accuracy of their analysis by using additional information from post-wait synchronization, barriers, and locks.  we demonstrate the use of this analysis by optimizing remote access on distributed memory machines. the optimizations include message pipelining, to allow multiple outstanding remote memory operations, conversion of two-way to one-way communication, and elimination of communication through data re-use. the performance improvements are as high as 20-35% for programs running on a cm-5 multiprocessor using the split-c language as a global address layer.  arvind krishnamurthy katherine yelick
reflection as a mechanism for software integrity verification  the integrity verification of a device's controlling software is an important aspect of many emerging information appliances. we propose the use of reflection, whereby the software is able to examine its own operation, in conjunction with cryptographic hashes as a basis for developing a suitable software verification protocol. for more demanding applications meta- reflective techniques can be used to thwart attacks based on device emulation strategies. we demonstrate how our approach can be used to increase the security of mobile phones, devices for the delivery of digital content, and smartcards.  diomidis spinellis
applicative caching: programmer control of object sharing and lifetime in. distributed implementations of applicative languages  the "referential transparency" of applicative language expressions demands that all occurrences of an expression in a given context yield the same value. in principle, that value therefore needs to be computed only once. however, in recursive programming, a context usually unfolds dynamically, precluding textual recognition of multiple occurrences, so that such occurrences are recomputed. to remedy the lack, in applicative languages, of an ability to store and retrieve a computed value under programmer control, "caching functionals" are proposed which allow the programmer to selectively avoid recomputation without overt use of assignment. the uses and implementation of such mechanisms are discussed, including reasons and techniques for purging the underlying cache. our approach is an extension of the early notion of "memo function", enabling improved space utilization and a "building-block" approach.  robert m. keller m. ronan sleep
demonic memory for process histories  demonic memory is a form of reconstructive memory for process histories. as a process executes, its states are regularly checkpointed, generating a history of the process at low time resolution. following the initial generation, any prior state of the process can be reconstructed by starting from a checkpointed state and re-executing the process up through the desired state, thereby exploiting the redundancy between the states of a process and the description of that process (i.e., a computer program).  the reconstruction of states is automatic and transparent. the history of a process may be examined as though it were a large two-dimensional array, or address space- time, with a normal address space as one axis and steps of process time as the other. an attempt to examine a state that is not physically stored triggers a "demon" which reconstructs that memory state before access is allowed.  regeneration requires an exact description of the original execution of the process. if the original process execution depends on non-deterministic events (e.g., user input), these events are recorded in an exception list, and are replayed at the proper points during re- execution.  while more efficient than explicitly storing all state changes, such a checkpointing system is still prohibitively expensive for many applications; each copy (or snapshot) of the system's state may be very large, and many snapshots may be required. demonic memory saves both space and time by using a virtual copy mechanism. (virtual copies share unchanging data with the objects that they are copies of, only storing differences from a prototype or original [mibk86].) in demonic memory, the snapshot at each checkpoint is a virtual copy of the preceding checkpoint's snapshot. hence it is called a virtual snapshot. in order to make the virtual snapshot mechanism efficient, state information is initially saved in relatively large units of space and time, on the order of pages and seconds, with single-word/single-step regeneration undertaken only as needed. this permits the costs of indexing and lookup operations to be amortized over many locations.  p. r. wilson t. g. moher
combining analyses, combining optimizations  modern optimizing compilers use several passes over a program's intermediate representation to generate good code. many of these optimizations exhibit a phase-ordering problem. getting the best code may require iterating optimizations until a fixed point is reached. combining these phases can lead to the discovery of more facts about the program, exposing more opportunities for optimization. this article presents a framework for describing optimizations. it shows how to combine two such frameworks and how to reason about the properties of the resulting framework. the structure of the frame work provides insight into when a combination yields better results. to make the ideas more concrete, this article presents a framework for combining constant propagation, value numbering, and unreachable-code elimination. it is an open question as to what other frameworks can be combined in this way.  cliff click keith d. cooper
object-oriented concurrent programming in cst  cst is a programming language based on smalltalk-80 that supports concurrency using locks, asynchronous messages, and distributed objects. distributed objects have their state distributed across many nodes of a machine, but are referred to by a single name. distributed objects are capable of processing many messages simultaneously and can be used to efficiently connect together large collections of objects. they can be used to construct a number of useful abstractions for concurrency. we describe the cst language and give examples of its use.  w. j. dally a. a. chien
adl - an interface definition language for specifying and testing software  this paper describes an interface definition language called adl which extends omg's corba interface definition language with formal specification constructs. in addition to adl's use in formal documentation, adl's primary use is for testing software. adl can be adapted for use with most programming languages.  this paper also presents an overview of a testing technology based on adl and presents the highlights of a test-data description language (tdd) used to describe test-data.  sriram sankar roger hayes