waashk/acm huggingface dataset:
an evaluation of the real-time performances of svr4.0 and svr4.2 unix is one of the most widely used operating systems on current workstations. however, unix was originally designed as a multitasking and time-sharing system with little concern for supporting real-time applications. recent versions of unix have incorporated real-time features and the designers of these systems claim to provide better response times than the standard unix kernel. in order to assess the benefits of these new features and verify these claims, this paper compares the real-time performances of two popular versions of unix namely system v release 4.0 and system v release 4.2 for the intel platform. sherali zeadally
a comparison of ada and java as a foundation teaching language java has entered the software arena in unprecedented fashion, upstaging languages and technologies that are longstanding players in the industry. almost unheard of before 1995, the language and its surrounding technology are attracting increasing attention not merely in the hardware and software communities but also among lay users and in the popular press. this phenomenon has not escaped the attention of academia, and a growing number of colleges and universities are looking at java as a candidate "foundation" language on which to base computer science curricula.this paper looks at the role of a programming language for teaching computer science courses and compares ada and java against the identified criteria. it concludes that ada is the superior choice, based on technical factors such as its more comprehensive feature set and its methodology-neutral design, and also taking into account external factors including the availability of good but inexpensive compilation environments.section 1 provides a brief overview of the java technology. section 2 identifies the criteria relevant to choosing a programming language for a foundation-level computer science course. section 3 compares ada and java with respect to the criteria related to technical aspects of the language, and section 4 compares the languages with respect to external factors. section 5 summarizes the conclusions of this analysis.appendix a furnishes a summary of the java language. it is assumed that the reader is familiar with ada, and thus an ada language summary is not included. web sites with links to ada information include [sigada], [kempe1], and [adaic]. benjamin m. brosgol
score '82 - a summary (at ibm systems research institute, 3/23-3/24/82)  "score '82", the first workshop on software counting rules, was attended by practitioners who are working with "software metrics". the concern was with methodologies for counting such software measurables as the number of "operators", "operands" or the number of lines of code in a program. a "metric" can be a directly countable "measurable" or a quantity computable from one or several such "measureables". "metrics" quantify attributes of the software development process, the software itself, or some aspect of the interaction of the software with the processor that hosts it. in general, a "metric" should be useful in the development of software and in measuring its quality. it should have some theory to support its existence, and it should be based on actual software data. this workshop was concerned principally with the data aspects of "metrics", especially with the rules underlying the collection of the data from which they are computed.  john e. gaffney
the program dependence graph and its use in optimization  in this paper we present an intermediate program representation, called the program dependence graph (pdg), that makes explicit both the data and control dependences for each operation in a program. data dependences have been used to represent only the relevant data flow relationships of a program. control dependences are introduced to analogously represent only the essential control flow relationships of a program. control dependences are derived from the usual control flow graph. many traditional optimizations operate more efficiently on the pdg. since dependences in the pdg connect computationally related parts of the program, a single walk of these dependences is sufficient to perform many optimizations. the pdg allows transformations such as vectorization, that previously required special treatment of control dependence, to be performed in a manner that is uniform for both control and data dependences. program transformations that require interaction of the two dependence types can also be easily handled with our representation. as an example, an incremental approach to modifying data dependences resulting from branch deletion or loop unrolling is introduced. the pdg supports incremental optimization, permitting transformations to be triggered by one another and applied only to affected dependences.  jeanne ferrante karl j. ottenstein joe d. warren
formal specification and development of an ada compiler - a vdm case study  the vienna development method (vdm) has been employed by dansk datamatik center (ddc) on a large-scale, industrial ada compiler development project. vdm is a formal specification and development method in that it insists on the initial specifications and all design steps being expressed in a formal (mathematically based) notation.  this paper gives an overview of how vdm was used in the various steps of the ddc ada project, and we guide the reader through the steps involved from the initial formal specification of ada down to the actually coded multipass compiler. finally we report on the quantitative and qualitative experiences we have gained, both as regards the technical suitability of vdm for the project and as regards the implications on software management and quality assurance.  geert b. clemmensen ole n. oest
axiomatic bootstrapping: a guide for compiler hackers  if a compiler for language l is implemented in l, then it should be able to compile itself. but for systems used interactively commands are compiled and immediately executed, and these commands may invoke the compiler; so there is the question of how ever to cross-compile for another architecture. also, where the compiler writes binary files of static type information that must then be read in by the bootstrapped interactive compiler, how can one ever change the format of digested type information in binary files?  here i attempt an axiomatic clarification of the bootstrapping technique, using standard ml of new jersey as a case study. this should be useful to implementors of any self-applicable interactive compiler with nontrivial object-file and runtime-system compatibility problems.  andrew w. appel
from objects to actors: study of a limited symbiosis in smalltalk-80  in this paper we describe an implementation of actors in smalltalk-80, named actalk. this attempt is designed as a minimal extension preserving the smalltalk-80 language.  actors are active and autonomous objects, as opposed to standard passive smalltalk-80 objects. an actor is built from a standard smalltalk-80 object by associating a process with it and by serializing the messages it could receive into a queue.  we will study the cohabitation and synergy between the two models of computation: transfer of active messages (message and thread of activity) between passive objects, and exchange of passive messages between active objects. we propose a sketch of methodology in order to have a safe combination between these two programming paradigms.  we show how to extend the actalk kernel into various extensions to define the basic actor model of computation, higher level programming constructs such as the 3 types of message passing (asynchronous, synchronous, and eager) proposed in the abcl/1 programming language, and distributed architectures. all these examples are constructed as simple extensions (by using inheritance) of our kernel model.  j.-p. briot
a comparative evaluation of object definition techniques for large prototype systems  although prototyping has long been touted as a potentially valuable software engineering activity, it has never achieved widespread use by developers of large-scale, production software. this is probably due in part to an incompatibility between the languages and tools traditionally available for prototyping (e.g., lisp or smalltalk) and the needs of large- scale-software developers, who must construct and experiment with large prototypes. the recent surge of interest in applying prototyping to the development of large- scale, production software will necessitate improved prototyping languages and tools appropriate for constructing and experimenting with large, complex prototype systems. we explore techniques aimed at one central aspect of prototyping that we feel is especially significant for large prototypes, namely that aspect concerned with the definition of data objects. we characterize and compare various techniques that might be useful in defining data objects in large prototypesystems, after first discussing some distinguishing characteristics of large prototype systems and identifying some requirements that they imply. to make the discussion more concrete, we describe our implementations of three techniques that represent different possibilities within the range of object definition techniques for large prototype systems.  jack c. wileden lori a. clarke alexander l. wolf
formal modeling of synchronization methods for concurrent objects in ada 95 one important role for ada programming is to aid engineering of concurrent and distributed software. in a concurrent and distributed environment, objects may execute concurrently and need to be synchronized to serve a common goal. three basic methods by which objects in a concurrent environment can be constructed and synchronized have been identified [1]. to formalize the semantics of these methods and to provide a formal model of their core behavior, we provide some graphic models based on the petri net formalism. the purpose of this formal modeling is to illustrate the possibility of automatic program analysis for object-oriented features in ada-95. models for the three distributed- object synchronization methods are discussed, and a potential deadlock situation for one of the methods/models is illustrated. we conclude with some comparison of the three methods in terms of the model abstractions. ravi k. gedela sol m. shatz haiping xu
a simple and efficient implmentation approach for single assignment languages  functional and single assignment languages have semantically pure features that do not permit side effects. this lack of side effects makes detection of parallelism in programs much easier. however, the same property poses a challenge in implementing these languages efficiently. a preliminary implementation of a compiler for the single assignment language, sisal, is described. the compiler uses reference counts for memory management and copy avoidance. performance results on a wide range of benchmark programs show that sisal programs compiled by our implementation run 2-3 times slower on average than the same programs written in c, pascal, and fortran, and orders of magnitude faster than other implementations of single assignment languages. extensions of these techniques for multiprocessor implementations are proposed.  kourosh gharachorloo vivek sarkar john l. hennessy
a research environment for incremental data flow analysis  this articles describes an environment intended for the study of incremental data flow analysis and the discovery of the types of programs for which this technique is effective. high-level data flow analysis using attribute grammars allows calculation of both data flow information and measurement information as computations on attribute sets. our results show that in the worst case our method of incremental data flow analysis uses a large amount of cpu time (and memory), but for programs with the same structure as a "typical program", performance is quite good.  zhiqiang tan karen a. lemone
why softwarre fails this note summarizes conclusions from a three year study about why released software fails. our method was to obtain mature-beta or retail versions of real software applications and stress test them until they fail. from an analysis of the causal faults, we have synthesized four reasons why software fails. this note presents these four classes of failures and discusses the challenges they present to developers and testers. the implications for software testers are emphasized. james a. whittaker alan jorgensen
computer user manuals in print: do they have a future?  what sort of a role will the printed page play in the computer user manuals of the future? i believe that print does have a future in this area, but not perhaps the future we might have foreseen five years ago. at that time nothing was less controversial than the viability of print as a medium of documentation. that viability is in question now, and to show how the questioning developed i propose to examine its beginnings in the recent past. i shall then go into some detail on how the controversy about print is being maintained at present. finally, i shall explain how i feel the controversy is likely to be resolved, by making four predictions about the future of computer user manuals, and those whose job it is to produce them.  john b mckee
sai-sddltm ...a tool for automated documentation  sai-sddl tm (science applications, inc. software design and documentation language) is a licensed computer program which aids in the documentation as well as the design of computer software. the three components of sai-sddl are: the processor, which is a pascal program; the language, which is simple, unrestrictive, and keyword-oriented; and the methodologies, which are numerous and well established. this workshop focuses on the methodologies and the results obtained by applying them.  donald a. heimburger marcia a. metcalfe
adaptable object migration: concept and implementation migration is one example of the insufficiently used potentials of distributed systems. although migration can enhance the efficiency and the reliability of distributed systems, it is still rarely used. two limitations contained in nearly all existing migration implementations prevent a widespread usage: migration is restricted to processes and the migration mechanism, i.e. the way state is transferred, is not adaptable to changing requirements.in our approach, migration is an operation provided by every object of any type. triggered by higher level migration policies, the object migrates itself using an object- specific migration mechanism. changing requirements are handled by higher level migration policies that adapt migration by exchanging the object's mechanisms.adaptable migration was implemented within the birlix operating system. different migration mechanisms are accomplished by different meta objects, which can be attached to other objects. if an object has to be migrated, the meta object does the migration. changing environmental requirements are handled by exchanging the meta object. as a result, each object has its own migration mechanism. the approach has been examined by implementing a couple of well-known migration mechanisms via meta objects. this paper describes the meta object implementation of the charlotte migration mechanism. wolfgang lux
noncorrecting syntax error recovery  a parser must be able to continue parsing after encountering a syntactic error to check the remainder of the input. to achieve this, it is not necessary to perform corrections on either the input text or the stack contents. a formal framework is provided in which noncorrecting syntax error recovery concepts are defined and investigated. the simplicity of these concepts allows the statement of provable properties, such as the absence of spurious error messages or the avoidance of skipping input text. these properties are due to the fact that no assumptions about the nature of the errors need be made to continue parsing.  helmut richter
graph-based code selection techniques for embedded processors  code selection is an important task in code generation for programmable processors, where the goal is to find an efficient mapping of machine- independent intermediate code to processor-specific machine instructions. traditional approaches to code selection are based on tree parsing which enables fast and optimal code selection for intermediate code given as a set of data-flow trees. while this approach is generally useful in compilers for general- purpose processors, it may lead to poor code quality in the case of embedded processors. the reason is that the special architectural features of embedded processors require performing code selection on data-flow graphs, which are a more general representation of intermediate code. in this paper, we present data-flow graph-based code selection techniques for two architectural families of embedded processors: media processors with support for simd instructions and fixed-point dsps with irregular data paths. both techniques exploit the fact that, in the area of embedded systems, high code quality is a much more important goal than high compilation speed. we demonstrate that certain architectural features can only be utilized by graph- based code selection, while in other cases this approach leads to a significant increase in code quality as compared to tree-based code selection.
asynchronous transfer of control in ada 9x  the taft proposal is described in detail. it involves introducing a new "and" clause into the select statement thereby providing a means of programming asynchronous transfer of control without the use of the abort facility. an evaluation of the proposal considers some of its limitations, the major one of which is the possibility of deadlock if a group of tasks use the facility to affect each other. ways of removing this difficulty are considered. the model is then compared with the alternative of introducing asynchronous exceptions. finally a unified model is presented that combines the advantages of the taft proposal and asynchronous exceptions.  a. burns a. j. wellings g. l. davies
analysis of transaction management performance  there is currently much interest in incorporating transactions into both operating systems and general-purpose programming languages. this paper provides a detailed examination of the design and performance of the transaction manager of the camelot system. camelot is a transaction facility that provides a rich model of transactions intended to support a wide variety of general-purpose applications. the transaction manager's principal function is to execute the protocols that ensure atomicity.  the conclusions of this study are: a simple optimization to two-phase commit reduces logging activity of distributed transactions; non-blocking commit is practical for some applications; multithreaded design improves throughput provided that log batching is used; multi-casting reduces the variance of distributed commit protocols in a lan environment; and the performance of transaction mechanisms such as camelot depend heavily upon kernel performance.  d. duchamp
leapfrogging: a portable technique for implementing efficient futures  a future is a language construct that allows programmers to expose parallelism in applicative languages such as multilisp [5] with minimal effort. in this paper we describe a technique for implementing futures, which we call leapfrogging, that reduces blocking due to load imbalance. the utility of leapfrogging is enhanced by the fact that it is completely platform- independent, is free from deadlock, and places a bound on stack sizes that is at most a small constant times the maximum stack size encountered during a sequential execution of the same computation. we demonstrate the performance of leapfrogging using a prototype implementation written in c++.  david b. wagner bradley g. calder
research directions in software reuse: where to go from here?  software reuse is no longer in its infancy. we are able to look back at more than 15 years of research and should use the opportunity of such a symposium to critically evaluate the past research in order to identify promising future research areas in software reuse.  in this paper, we give a broader view of reuse and some of the so far less- considered areas, which we believe may support software reuse to get off the ground. we mention our ongoing research in software reuse, discussing reuse experiments in the areas of long-term software evolution and component programming.  furthermore, we indicate the critical importance of interactions among the reuse and related communities within software engineering, such as the object- oriented and the software maintenance communities.  harald gall mehdi jazayeri rene klosch
modeling distributed file systems  this paper describes different methods and techniques used to model, analyze, evaluate and implement distributed file systems. distributed file systems are categorized by the distributed system hardware and software architecture, in which they are implemented as well as by the file systems' functions. in addition, distributed file system performance depends on the load executed in the system. modeling and anlysis of distrubed file systems requires new methods to approximate complexity of the system and to provide a useful solution. the complexity of the distributed file system is reflected in the possible placement of the files, file replication, and migration of files and processes. the synchronization mechanisms are needed to control file access. file sharing involves load sharing.  in distributed environment. anna hac
generalized and stationary scrolling  we present a generalized definition of scrolling that unifies a wide range of existing interaction techniques, from conventional scrolling through pan and zoom systems and fish- eye views. furthermore it suggests a useful class of new scrolling techniques in which objects do not move across the display. these "stationary scrolling" techniques do not exhibit either of two problems that plague spatial scrolling system: discontinuity in salience and the undermining of the user's spatial memory.  randall b. smith antero taivalsaari
an ada code generator for vax 11/780 with unix  this paper describes the final phase of an ada compiler which produces code for the vax 11/780 running the unix operating system. problems encountered in the implementation of subprogram calls, parameter passing, function return values, and exception handling are discussed and their solutions outlined.  an underlying requirement for the code generator has been speed of implementation consistent with being a test bed for an ada implementation. to accomplish this, a common model for the target environment has been assumed. the assumptions include: the vaxis a stack machine, a single address space is used, only the general case is implemented (no optimization of special cases), the hardware does as much work as possible, run time routines for lengthy code sequences are acceptable, and the conventions given in the vax architecture, hardware, and software manuals are used.  the code generator has been running on a pdp-10 with tops-10, producing a vax assembly language source program as output. it has been available to local users since the beginning of 1980.  mark sherman andy hisgen david alex lamb jonathan rosenberg