waashk/acm huggingface dataset:
the unix eighth edition network file system  this talk will summarize the design goals for, performance of, and troubles with the eighth edition unix network file system. the principal goal was to make available the file systems of other machines to programs running on one machine (the client) without changing the semantics of system calls. the network file system did not need to provide for execution of programs on other machines, since our network already had a mechanism for that. the requirement that the semantics of system calls be preserved has several implications: names of remote files must be syntactically and semantically the same as names of local files; the current directory can be either a local directory or a remote directory, so the kernel has to be modified. these goals have been met. no program had to be recompiled to use remote files, and except for bugs, and a few subtle points discussed below, programs cannot distinguish between local and remote files.  this is an abstract of a longer paper which will include the results of the current reimplementation.  peter j. weinberger
using prototypical objects to implement shared behavior in object-oriented systems  a traditional philosophical controversy between representing general concepts as abstract sets or classes and representing concepts as concrete prototypes is reflected in a controversy between two mechanisms for sharing behavior between objects in object oriented programming languages. inheritance splits the object world into classes, which encode behavior shared among a group of instances, which represent individual members of these sets. the class/instance distinction is not needed if the alternative of using prototypes is adopted. a prototype represents the default behavior for a concept, and new objects can re-use part of the knowledge stored in the prototype by saying how the new object differs from the prototype. the prototype approach seems to hold some advantages for representing default knowledge, and incrementally and dynamically modifying concepts. delegation is the mechanism for implementing this in object oriented languages. after checking its idiosyncratic behavior, an object can forward a message to prototypes to invoke more general knowledge. because class objects must be created before their instances can be used, and behavior can only be associated with classes, inheritance fixes the communication patterns between objects at instance creation time. because any object can be used as a prototype, and any messages can be forwarded at any time, delegation is the more flexible and general of the two techniques.  henry lieberman
separating content from form: a language for formatting on-line documentation and dialog  recent research has demonstrated the advantages of separating management of the user interface from the application program. a user interface system should integrate access to on-line help and documentation with other dialog for interacting with the program into a uniform environment. we describe such a user interface management system, called ice, with emphasis on its facilities for authoring networks of frames containing help information and menus for interacting with the application program. authors can write help and dialog using a language similar to the scribe document processing system, widely used at cmu and elsewhere. but instead of generating hardcopy documents for different printing devices, ice produces interactive "softcopy" documents, consisting of a network of frames combining documentation and interface.  in ice the screen layout of frames and the style of interaction is specified in a format file which is separate from the dialog file that contains the text to appear in the frames. this separation allows the dialog author to write the text without having to worry much about its precise appearance on the screen. the display designer can specify the actual format independently. the same text can be formatted in different ways to make use of different display devices and to allow experimentation with alternative formats and styles of interaction.  charlie wiecha max henrion
a study of file sizes and functional lifetimes  the performance of a file system depends strongly on the characteristics of the files stored in it. this paper discusses the collection, analysis and interpretation of data pertaining to files in the computing environment of the computer science department at carnegie-mellon university (cmu-csd). the information gathered from this work will be used in a variety of ways:  1\\. as a data point in the body of information available on file systems.  2\\. as input to a simulation or analytic model of a file system for a local network, being designed and imlemented at cmu-csd [1].  3\\. as the basis of implementation decisions and parameters for the file system just mentioned.  4\\. as a step toward understanding how a user community creates, maintains and uses files.  m. satyanarayanan
software technology maturation  we have reviewed the growth and propagation of a variety of software technologies in an attempt to discover natural characteristics of the process as well as principles and techniques useful in transitioning modern software technology into widespread use. what we have looked at is the technology maturation process, the process by which a piece of technology is first conceived, then shaped into something usable, and finally "marketed" to the point that it is found in the repertoire of a majority of professionals.  a major interest is the time required for technology maturation --- and our conclusion is that technology maturation generally takes much longer than popularly thought, especially for major technology areas. but our prime interest is in determining what actions, if any, can accelerate the maturation of technology, in particular that part of maturation that has to do with transitioning the technology into widespread use. our observations concerning maturation facilitators and inhibitors are the major subject of this paper.  samuel t. redwine william e. riddle
give-n-take - a balanced code placement framework  give-n-take is a code placement framework which uses a general producer- consumer concept. an advantage of give-n-take over existing partial redundancy elimination techniques is its concept of production regions, instead of single locations, which can be beneficial for general latency hiding. give-n-take guaranteed balanced production, that is, each production will be started and stopped once. the framework can also take advantage of production coming "for free," as induced by side effects, without disturbing balance. give- n-take can place production either before or after consumption, and it also provides the option to hoist code out of potentially zero-trip loop (nest) constructs. give-n-take uses a fast elimination method based on tarjan intervals, with a complexity linear in the program size in most cases.  we have implemented give-n-take as part of a fortran d compiler prototype, where it solves various communication generation problems associated with compiling data-parallel languages onto distributed- memory architectures.  reinhard von hanxleden ken kennedy
when bears are blue and bulls are red analysts deal with real numerical data. often the data is collected over time. because numbers are abstract, analysts often use graphs to make numerical data more meaningful. real data typically fluctuates in some random fashion. however, patterns often exist in the data. an example would be the seasonal fluctuations in commodities. analysts use a variety of techniques to help them find patterns that have the potential to improve their skill in predicting future trends. this paper suggests some ways to make some of these patterns more obvious.we are here presenting techniques to enhance traditional methods of providing information in graphs. by taking advantage of current computer technology to provide graphic images and to draw graphs, new and exciting visual images are possible. in addition, animation strategies allow us to simulate the passage of time. finally, we add a whimsical touch.by animating the graphs of mathematical functions we illuminate aspects of the graphing process which might otherwise go unnoticed. the focus of this paper is on curve fitting. apl and j provide the matrix divide function for finding the coefficients of the constant, linear, quadratic, cubic or nth degree polynomial which best fit a collection of data.each of these polynomials also has a polynomial derivative. these derivatives are useful for three reasons. select a point on the x-axis. the y-value of the polynomial is the height of the polynomial for that x-value. but the y-value of the derived polynomial for the chosen x-value provides information about the original polynomial in three ways. first the y-value for the chosen x-value is the slope of the original polynomial at that point. the second useful aspect of the derivative is that positive and negative values indicate when the original polynomial is increasing or decreasing. a derivative is one degree less than the original polynomial so for example, a cubic polynomial has a quadratic polynomial derivative.applications will demonstrate how the slope of the tangent together with the use of images and color can enhance the reader's ability to assimilate data. these enhancements give additional meaning to graphs and add life to the data. linda alvord tama traberman
applying object-oriented metrics to ada 95 ada 95 adds many new and notable features to the ada 83 standard. the additions include such aspects as object- oriented programming, hierarchical libraries, and protected objects. the enhancements to the language may have a profound impact on the way developers design software in ada. consequently, the way in which the new software designs are assessed needs to be addressed. recent studies suggest traditional functionally-oriented metrics are not applicable to object-oriented software. as a result, new measures are being proposed that may be applicable to object- oriented design. some of these metrics have been validated on small to medium sized projects written in c++ and smalltalk. this paper demonstrates how to apply these metrics to ada 95. william w. pritchett
the benefits and costs of dyc's run-time optimizations  dyc selectively dynamically compiles programs during their execution, utilizing the run-time-computed values of variables and data structures to apply optimizations that are based on partial evaluation. the dynamic optimizations are preplanned at static compile time in order to reduce their run-time cost; we call this staging. dyc's staged optimizations include (1) an advanced binding-time analysis that supports polyvariant specialization (enabling both single-way and multiway complete loop unrolling), polyvariant division, static loads, and static calls, (2) low- cost, dynamic versions of traditional global optimizations, such as zero and copy propagation and dead- assignment elimination, and (3) dynamic peephole optimizations, such as strength reduction. because of this large suite of optimizations and its low dynamic compilation overhead, dyc achieves good performance improvements on programs that are larger and more complex than the kernels previously targeted by other dynamic compilation systems. this paper evaluates the benefits and costs of applying dyc's optimizations. we assess their impact on the performance of a variety of small to medium-sized programs, both for the regions of code that are actually transformed and for the entire application as a whole. our study includes an analysis of the contribution to performance of individual optimizations, the performance effect of changing the applications' inputs, and a detailed accounting of dynamic compilation costs.  brian grant markus mock matthai philipose craig chambers susan j. eggers
updating a master file - yet one more time  for several years i have been teaching a file updating algorithm which is essentially the same as that in dwyer's admirable paper [1]. there is one unjustified objection to the algorithm that perceptive students and people with batch processing experience almost invariably raise and which is not addressed by dwyer. the objection is based on a situation which arises in a batch processing environment with several users, where key-ordered sequential update is used.  j. inglis
a niche for structured flowcharts (abstract only)  the research investigated the preferences for graphical methods, such as structured flowcharts, and for verbal methods, such as pseudocode, when learning short, relatively complex algorithms. the research summarizes the data from six replications using 193 students and 16 data structures classes. a preference for flowcharts was hypothesized under eight conditions. all eight conditions produced large differences which were statistically significant. the preferences for flowcharts ranged from 75.1% to 89.1%. probabilities associated with these eight significant conditions ranged from p ≤ .0000001 × 10-23 to p ≤ .0000001 × 10-5. no statistically significant preferences were found for pseudocode. the results indicate that graphical methods should be strongly considered when teaching relatively complex algorithms. more specifically, the results indicate that data structures students strongly prefer a structured flowchart presentation in books and in lectures. the students also prefer to view a structured flowchart version of an algorithm before viewing a pseudocode version when given the opportunity to use both algorithmic learning techniques. including two other recent studies on structured flowchart preference, there are now eight full- and-partial replications which have produced nearly identical findings. the students found the data structures algorithms easier to comprehend when structured flowcharts were used. the results of these eight replications support the use of structured flowcharts in the instruction of short, relatively complex algorithms. the research does not support the use of structured flowcharts in any other context.  david scanlan
interprocedural pointer alias analysis  we present practical approximation methods for computing and representing interprocedural aliases for a program written in a language that includes pointers, reference parameters, and recursion. we present the following contributions: (1) a framework for interprocedural pointer alias analysis that handles function pointers by constructing the program call graph while alias analysis is being performed; (2) a flow-sensitive interprocedural pointer alias analysis algorithm; (3) a flow- insensitive interprocedural pointer alias analysis algorithm; (4) a flow-insensitive interprocedural pointer alias analysis algorithm that incorporates kill information to improve precision; (5) empirical measurements of the efficiency and precision of the three interprocedural alias analysis algorithms.  michael hind michael burke paul carini jong-deok choi
the cornell program synthesizer: a syntax-directed programming environment  programs are not text; they are hierarchical compositions of computational structures and should be edited, executed, and debugged in an environment that consistently acknowledges and reinforces this viewpoint. the cornell program synthesizer demands a structural perspective at all stages of program development. its separate features are unified by a common foundation: a grammar for the programming language. its full-screen derivation-tree editor and syntax-directed diagnostic interpreter combine to make the synthesizer a powerful and responsive interactive programming tool.  tim teitelbaum thomas reps
mostly-copying reachability-based orthogonal persistence  we describe how reachability-based orthogonal persistence can be supported even in uncooperative implementations of languages such as c++ and modula-3, and without modification to the compiler. our scheme extends bartlett's mostly- copying garbage collector to manage both transient objects and resident persistent objects, and to compute the reachability closure necessary for stabilization of the persistent heap. it has been implemented in our prototype of reachability-based persistence for modula-3, yielding performance competitive with that of comparable, but non-orthogonal, persistent variants of c++. experimental results, using the 007 object database benchmarks, reveal that the mostly-copying approach offers a straightforward path to efficient orthogonal persistence in these uncooperative environments. the results also characterize the performance of persistence implementations based on virtual memory protection primitives.  antony l. hosking jiawan chen
using models in software engineering  the software engineering institute (sei) has participated in several projects1 in which the focus was on helping contractors make use of good software engineering methods and ada. during this participation, we have learned several important lessons about the development of software for both large- scale and embedded systems. we have noticed that after a long period of time where the focus on productivity generated searches for new methodologies, tools, and ways to write reusable software, the emphasis has shifted to quality, in recognition of the fact that the new methods and tools were not adequate to address the problems occurring at the design level. we propose that the industry instead concentrate the search for the old methods still in use in the other branches of engineering, and apply those methods to the software problem.  r. d'ilppolito
the stream machine: a data flow architecture for real-time applications  the stream machine is a software architecture designed to support the development and evolution, as well as the efficient execution, of software that performs both data acquisition and process control under real-time constraints. a stream machine program consists of a set of concurrently executing modules communicating through streams of data. streams provide essentially a data flow style of communication, thereby supporting deterministic data acquisition and calculation. the basic constructs have been augmented by several time-based operations to support process control software. in addition, explicit declarations of timing constraints layered on stream machine programs are currently being explored for resource allocation and scheduling. our experience to date with two implementations of the stream machine suggests that it facilitates the mixture of software that performs both data acquisition and process control.  paul barth scott guthery david barstow
object-oriented programming in scheme  we describe a small set of additions to scheme to support object-oriented programming, including a form of multiple inheritance. the extensions proposed are in keeping with the spirit of the scheme language and consequently differ from lisp-based object systems such as flavors and the common lisp object system. our extensions mesh neatly with the underlying scheme system. we motivate our design with examples, and then describe implementation techniques that yields efficiency comparable to dynamic object-oriented language implementations considered to be high performance. the complete design has an almost-portable implementation, and the core of this design comprises the object system used in t, a dialect of scheme. the applicative bias of our approach is unusual in object-oriented programming systems.  norman adams jonathan rees
third eye - specification-based analysis of software execution traces (poster session)  another concept of third eye is the tracing state. tracing state is a set of event types generated in that state, other event types are filtered out and not reported. the system is always in a specific tracing state. tracing states correspond to specifications. a program specification describes a set of constraints on events. the event types used in a specification have to be monitored to validate a trace against this specification. all event types contained in a specification and monitored for this specification form a tracing state. tracing states also control the overhead of tracing on the executing system.  the third eye framework includes modules for event type definition, event generation and reporting, tracing state definition and management, trace logging, query and browsing interfaces. modules of event type definition, event reporting facility and tracing state controler are integrated with the software of the system under trace (sut). the rest of the modules are independent from the sut and can be deployed on a different execution platform to minimize the influence on system performance. trace delivery for logging and analysis uses alternative interfaces to accommodate devices with different data storage and connectivity capabilities.  we have implemented third eye framework prototype currently used by the third eye project team in collaboration with product development teams in nokia's business units. we used third eye to test a number of software systems: the memory subsystem of one of nokia's handsets, apache web server, and wap (wireless application protocol) client. wap is an industrial standard for applications and services that operate over wireless communication networks. we validated message sequences in this protocol by adding events in the functions that correspond to the protocol primitives and then checking whether the event sequence corresponds to the protocol message sequence. events are mapped to prolog facts and constraints are expressed as prolog rules. third eye can be used for debugging, monitoring, specification validation, and performance measurements. these scenarios use typed events---a concept simple and yet expressive enough to be shared by product designers and developers. the third eye has an open architecture allowing easy replacement of third- party tools, including databases, analysis and validation tools. third eye is a practical framework for specification-based analysis and adaptive execution tracing of software systems.  raimondas lencevicius alexander ran rahav yairi
the software life cycle support environment (slcse): a computer based framework for developing software systems  the software life cycle support environment (slcse) is a vax/vms-based software development environment framework which presents a common and consistent user interface accessing a comprehensive set of software development tools supporting the full spectrum of dod-std-2 167a software life cycle activities from requirements analysis to maintenance. these tools utilize a project database which maintains information relevant not only to the software under development (e.g., requirements allocation, software interfaces, etc.), but also information relating to the project as a whole (e.g., schedules, milestones, quality assurance, configuration management, etc.). the project database supports the dod-std-2167a life cycle model and associated data item descriptions (dids). slcse's framework approach supports the integration of new tools into the environment and permits the slcse to evolve over time and adapt to advances in software engineering technology.  tom strelich
the impact of apl2 on teaching apl  with the advent of significant new features in apl, for example apl2, attention to and an understanding of the fundamental principles and concepts of apl is especially important. this expository paper is aimed primarily at the apl educator, present or future, and the person seriously pursuing a more in-depth mastery of the language. the paper states some of the underlying concepts and principles of the language and why they are important. within the presentation several techniques which the author has found successful in conveying these concepts are stated. finally, the fact that apl2 permits another new and different approach to problem solving is discussed and illustrated.  raymond p. polivka