waashk/acm huggingface dataset:
knowledge production from different worlds: what can happen when technical writers speak for engineers at the turn of the 20th century, technical writers in the united states were mostly engineers who both developed technology and wrote about it. during world war ii, however, some engineers seeking to increase the efficiency of technology development separated their engineering from their communication tasks. this trend opened up a new occupation for non- engineering technical writers who communicated knowledge made by engineers. while this specialization may have allowed engineers to develop technology more efficiently, it also allowed non-scientists to give voice to scientific knowledge and by the 1970s created tensions between practitioners in scientific fields and liberal arts-trained technical writers. how could non- scientists give scientific knowledge its material form through communication? and did this arrangement between engineers and writers too often render engineers mute within their own professions? this paper traces a cultural history of technical writing practice in the united states and explores current trends in the academy which aim to prepare engineers more adequately for communicating about their work. finally, this paper suggests that technical editors, as distinguished from traditional technical writers, can accommodate both an engineer's need to give voice to technology developments and a writer's contributions to shaping that voice into effective communication. bernadette longo
profiling in an object-oriented design environment that supports ada 9x and ada 83 code generation  object-oriented techniques for design and development have taken a strong hold in academia, industry, and government. our efforts in this area have been in the development of the object-oriented design environment, adam, that is programming-language independent and generates compilable code in ada 83, ada 9x, c++, and ontos c++. a key aspect of adam, short for active design and analyses modeling, is the requirement that software engineers supply profiles when defining the different components in their applications. a profile contains information on both the content (the purpose and constituent pieces) and context (interdependencies) for all components in an application. profiles are critical since they force software engineers to thoroughly understand and define each portion of an application. they are fundamental to the support of the ada 9x code generation process, and also provide the basis for analyzing an application. in this paper, we focus on profiles in adam and their support for the recently developed ada 9x code generator. we also briefly report on the role that adam has and will play in education and retraining, as related to object-oriented design and upgrading skills from ada 83 to ada 9x.  k. el guemhioui steven a. demurjian t. j. peters h. j. c. ellis
translation of the protected type mechanism in ada 83 several features of the ada 94 language are useful to improve the efficiency of ada programs. especially the protected type mechanism is useful to improve the efficiency of concurrent ada programs sharing common data structures. in order to facilitate the transition to ada 94 before ada 94 compilers are widely available, this paper proposes the use of an adapter which can be either a methodology, or an automatic translator. the adapter accepts source including protected objects and produces ada 83 source. the results of several tests show that the performances of concurrent programs can be dramatically improved by using protected objects. pascal ledru
a compiler approach to scalable concurrent-program design  we describe a compilation system for the concurrent programming language program composition notation (pcn). this notation provides a single- assignment programming model that permits concurrent- programming concerns such as decomposition, communication, synchronization, mapping, granularity, and load balancing to be addressed separately in a design. pcn is also extensible with programmer-defined operators, allowing common abstractions to be encapsulated and reused in different contexts.  the compilation system incorporates a concurrent-transformation system that allows abstractions to be defined through concurrent source-to-source transformations; these convert programmer-defined operators into a core notation. run-time techniques allow the core notation to be compiled into a simple concurrent abstract machine which can be implemented in a portable fashion using a run-time library. the abstract machine provides a uniform treatment of single-assignment and mutable data structures, allowing data sharing between concurrent and sequential program segments and permitting integration of sequential c and fortran code into concurrent programs.  this compilation system forms part of a program development toolkit that operates on a wide variety of networked workstations, multicomputers, and shared-memory multiprocessors. the toolkit has been used both to develop substantial applications and to teach introductory concurrent-programming classes, including a freshman course at caltech.  ian foster stephen taylor
optimal clock synchronization  we present a simple, efficient, and unified solution to the problems of synchronizing, initializing, and integrating clocks for systems with different types of failures: crash, omission, and arbitrary failures with and without message authentication. this is the first known solution that achieves optimal accuracy---the accuracy of synchronized clocks (with respect to real time) is as good as that specified for the underlying hardware clocks. the solution is also optimal with respect to the number of faulty processes that can be tolerated to achieve this accuracy.  t. k. srikanth sam toueg
cartablanca - a pure-java, component-based systems simulation tool for coupled non-linear physics on unstructured grids  this paper describes a component-based non-linear physical system simulation prototyping package written entirely in java using object-oriented design to provide scientists and engineers a "developer-friendly" software environment for large-scale computational method and physical model development. the software design centers on the jacobian-free newton-krylov solution method surrounding a finite-volume treatment of conservation equations. this enables a clean component-based implementation. we first provide motivation for the development of the software and then describe software structure. discussion of software structure includes a description of the use of java's built-in thread facility that enables data-parallel, shared-memory computations on a wide variety of unstructured grids with triangular, quadrilateral, tetrahedral and hexahedral elements. we also discuss the use of java's inheritance mechanism in the construction of a hierarchy of physics-systems objects and linear and non-linear solver objects that simplify development and foster software re-use. as a compliment to the discussion of these object hierarchies, we provide a brief review of the jacobian-free newton-krylov nonlinear system solution method and discuss how it fits into our design. following this, we show results from preliminary calculations and then discuss future plans including the extension of the software to distributed memory computer systems.  w. b. vanderheyden e. d. dendy n. t. padial- collins
deriving hard real-time embedded systems implementations directly from sdl specifications  object-oriented methodologies together with formal description techniques (fdt) are a promising way to deal with the increasing complexity of hard real- time embedded systems. however, fdts do not take into account non-functional aspects as real-time constraints. based on a new real- time execution model for fdt sdl proposed in previous works, a way to derive implementations of hard real-time embedded systems directly from sdl specifications is presented. in order to get it we propose a middleware that supports this model to organize the execution of the tasks generated from sdl system specification. additionally, a worst case real-time analysis, including the middleware overhead, is presented. finally, an example to generate the implementation from the sdl specification and a performance study is developed.  j. m. alvarez m. diaz l. llopis e. pimentel j. m. troyal
igor: a system for program debugging via reversible execution  typical debugging tools are insufficiently powerful to find the most difficult types of program misbehaviors. we have implemented a prototype of a new debugging system, igor, which provides a great deal more useful information and offers new abilities that are quite promising. the system runs fast enough to be quite useful while providing many features that are usually available only in an interpreted environment. we describe here some improved facilities (reverse execution, selective searching of execution history, substitution of data and executable parts of the programs) that are needed for serious debugging and are not found in traditional single-thread debugging tools. with a little help from the operating system, we provide these capabilities at reasonable cost without modifying the executable code and running fairly close to full speed. the prototype runs under the dune distributed operating system.  the current system only supports debugging of single-thread programs. the paper describes planned extensions to make use of extra processors to speed the system and for applying the technique to multi- thread and time dependent executions.  stuart i. feldman channing b. brown
optimal register assignment to loops for embedded code generation  one of the challenging tasks in code generation for embedded systems is register assignment. when more live variables than registers exist, some variables will necessarily be accessed from data memory. because loops are typically executed many times and are often time-critical, good register assignment in loops is exceedingly important as accessing data memory can degrade performance. the issue of finding an optimal register assignment to loops has been open for some time. in this article, we present a technique for optimal (i.e., spill minimizing) register assignment to loops. first we present a technique for register assignment to architecture styles that are characterized by a consolidated register file. then we extend the technique to include architecture styles that are characterized by distributed memories and/or a combination of general- and special-purpose registers. experimental results demonstrate that although the optimal algorithm may be computationally prohibitive, heuristic versions obtain results with performance better than that of an existing graph coloring approach.  david j. kolson alexandru nicolau nikil dutt ken kennedy
the use and disuse of apl: an empirical study  a sample of over 200 workspaces containing over 80,000 lines of code were analyzed to determine their composition and structure. statistics were gathered on the frequency of all monadic and dyadic functions, operators, system variables and functions as well as other workspace and defined function characteristics. the results of the study indicated that only a fraction of the apl primitive function set was being utilized despite the language's richness. the ubiquitous 80-20 phenomenon was well represented. in general, 80% of all apl usage occurred with 20% of the available function set. this seems to support a contention that more awareness needs to be directed toward "thinking primitive" instead of only "thinking array". some comparisons with a previous study by saal and weiss will be made.  raymond kanner
system documentation as software  accuracy, timeliness, flexibility, and low cost---computer buyers want better documentation, they want it now, they want it to suit their needs, and they want it cheap.  unfortunately, current documentation methods have failed to satisfy these needs. the inadequacies of the traditional technical manual are well known to anyone who has tried to use one, regardless of the herculean effort it probably took to collect and publish the damn thing. typically, the resources that could have been expended in making the manual easier to read were expended in an impossible battle to make the information available in a reasonable amount of time, without totally sacrificing the accuracy of its contents.  the solution to this dilemma lies in changing the way that we view documentation. we must stop thinking of documentation as pieces of paper and start thinking of it as software.  geoffrey james sickler
turbodostm multiprocessor operating system  the turbodos operating system is a product of software 2000, inc., and is trademarked and copyrighted by them. at musys corp., we have used turbodos in conjunction with various slave processor boards to construct a wide variety of s-100 based computer systems, ranging from two to over sixty users.  turbodos is designed for multiprocessor networks of z-80 based computers, although single user versions are available. extensive use is made of the z-80 instruction set to achieve a highly table oriented and reentrant architecture, which is very adaptable to the user's environment. in addition to musys, many companies are selling turbodos for specific hardware configurations on an oem basis. this is one of the primary distinctions with other multiprocessor operating systems, which are supported by only a single vendor.  william a. schultz
on the cost of fault-tolerant consensus: when there are no faults (preliminary version) we consider the consensus problem in an asynchronous model enriched with unreliable failure detectors and in the partial synchrony model. we consider algorithms that solve consensus and tolerate crash failures and/or message omisions. we prove tight lower bounds on the number of communication steps performed by such algorithms in failure-free executions. we present in a unified framework a number of related lower bound results. thus, we shed light on the relationship among different known lower and upper bounds, and at the time, illustrate a general technique for obtaining simple and elegant lower bound proofs. we also illustrate matching upper bounds: we algorithms that achieve the lower bound. idit keidar sergio rajsbaum
directions in computer security  one of the primary thrusts in operating system security has come from the department of defense (dod), which early recognized the need for security controls in open use, multi-user, resource-shared computer systems.1 two features in particular, mandatory access controls and security kernel technology, have been strongly promoted by the dod. mandatory access controls, necessary to support a security policy that cannot be circumvented by any user (in dod's case, the national security policy regarding personnel clearances and data classifications) are being studied for their applicability to business2 and industry security problems. security kernel technology is an implementation of the reference monitor concept, a security enforcement abstraction which views a computer system as composed of subjects (e.g., processes, users) and objects (e.g., files) and a reference monitor which checks each access by a subject to an object. in the past ten years, several attempts to build secure operating systems have utilized security kernel technology. while none of these attempts was practical from a performance point of view, the security kernel research still serves as a basis for current attempts to build secure systems.  in a continuing effort to promote secure systems for dod use, the dod computer security center was formed in 1981. one of the first tasks of the center was to draft a "trusted computer system evaluation criteria" which defines various levels of protection for computer systems.3 in addition to listing feature requirements, including auditing, labelling, mandatory access controls, discretionary access controls, identification and authentication, the criteria discuss both the structure and development techniques used to produce trusted systems.  anne-marie g. claybrook
reifying variants in configuration management  using a solid software configuration management (scm) is mandatory to establish and maintain the integrity of the products of a software project throughout the project's software life cycle. even with the help of sophisticated tools, handling the various dimensions of scm can be a daunting (and costly) task for many projects. the contribution of this article is to (1)propose a method (based on the use creational design patterns) to simplify scm by reifying the variants of an object-oriented software system into language-level objects and (2)show that newly available compilation technology makes this proposal attractive with respect to performance (memory footprint and execution time) by inferring which classes are needed for a specific configuration and optimizing the generated code accordingly.  jean-marc jezequel
thread-specific heaps for multi-threaded programs  garbage collection for a multi-threaded program typically involves either stopping all threads while doing the collection or involves copious amounts of synchronization between threads. however, a lot of data is only ever visible to a single thread, and such data should ideally be collected without involving other threads.  given an escape analysis, a memory management system may allocate thread- specific data in thread-specific heaps and allocate shared data in a shared heap. garbage collection of data in a thread-specific heaps can be done independent of other threads and of data in their thread- specific heaps. for multi-threaded programs, thread-specific heaps allow reduced garbage collection latency for active threads. on multi-processor computers, thread- specific heaps allow concurrent garbage collection of different thread- specific heaps with minimal synchronization overhead.  we present an escape analysis and a sample memory management system using thread-specific heaps.  bjarne steensgaard
apl and mastermind a course in programming languages should teach students about the syntax and semantics of programming languages, as well as make them aware that a good choice of a programming language can often make a problem much easier to solve. this last point can best be made by giving students a problem that is much easier to solve in one language than in most others.the game of mastermind is an excellent vehicle for doing this. it is easy to understand, fun to play, and wonderfully easy to program in apl. mastermind has also been used to teach many concepts in combinatorics [5]. this paper outlines how to program the game of mastermind in apl. it also presents a strategy which is extremely simple but surprisingly effective. richard zaccone
design and implementation of a distributed virtual machine for networked computers this paper describes the motivation, architecture and performance of a distributed virtual machine (dvm) for networked computers. dvms rely on a distributed service architecture to meet the manageability, security and uniformity requirements of large, heterogeneous clusters of networked computers. in a dvm, system services, such as verification, security enforcement, compilation and optimization, are factored out of clients and located on powerful network servers. this partitioning of system functionality reduces resource requirements on network clients, improves site security through physical isolation and increases the manageability of a large and heterogeneous network without sacrificing performance. our dvm implements the java virtual machine, runs on x86 and dec alpha processors and supports existing java-enabled clients. emin gun sirer robert grimm arthur j. gregory brian n. bershad
the trw software productivity system  this paper presents an overview of the trw software productivity system (sps), an integrated software support environment based on the unix operating system, a wide range of trw software tools, and a wideband local network. section 2 summarizes the quantitative and qualitative requirements analysis upon which the system is based. section 3 describes the key architectural features and system components. finally, section 4 discusses our conclusions and experience to date.  barry w. boehm james f. elwell arthur b. pyster e. donald stuckle robert d. williams
a distributed unix system based on a virtual circuit switch  the popular unixtm operating system provides time-sharing service on a single computer. this paper reports on the design and implementation of a distributed unix system. the new operating system consists of two components: the s-unix subsystem provides a complete unix process environment enhanced by access to remote files; the f-unix subsystem is specialized to offer remote file service. a system can be configured out of many computers which operate either under the s-unix or the f-unix operating subsystem. the file servers together present the view of a single global file system. a single-service view is presented to any user terminal connected to one of the s-unix subsystems.  computers communicate with each other through a high-bandwidth virtual circuit switch. small front-end processors handle the data and control protocol for error and flow-controlled virtual circuits. terminals may be connected directly to the computers or through the switch.  operational since early 1980, the system has served as a vehicle to explore virtual circuit switching as the basis for distributed system design. the performance of the communication software has been a focus of our work. performance measurement results are presented for user process level and operating system driver level data transfer rates, message exchange times, and system capacity benchmarks. the architecture offers reliability and modularly growable configurations. the communication service offered can serve as the foundation for different distributed architectures.  g. w.r. luderer h. che j. p. haggerty p. a. kirslis w. t. marshall
experiences creating a portable cedar  cedar is the name for both a language and an environment in use in the computer science laboratory at xerox parc since 1980. the cedar language is a superset of mesa, the major additions being garbage collection and runtime types. neither the language nor the environment was originally intended to be portable, and for many years ran only on d-machines at parc and a few other locations in xerox. we recently re- implemented the language to make it portable across many different architectures. our strategy was, first, to use machine-dependent c code as an intermediate language, second, to create a language-independent layer known as the portable common runtime, and third, to write a relatively large amount of cedar-specific runtime code in a subset of cedar itself. by treating c as an intermediate code we are able to achieve reasonably fast compilation, very good eventual machine code, and all with relatively small programmer effort. because cedar is a much richer language than c, there were numerous issues to resolve in performing an efficient translation and in providing reasonable debugging. these strategies will be of use to many other porters of high-level languages who may wish to use c as an assembler language without giving up either ease of debugging or high performance. we present a brief description of the cedar language, our portability strategy for the compiler and runtime, our manner of making connections to other languages and the unix* operating system, and some measures of the performance of our "portable cedar".  r. atkinson a. demers c. hauser c. jacobi p. kessler m. weiser