waashk/acm huggingface dataset:
assessing grasp utilization through instrumentation the idea that representing something visually can help us understand it has long been promoted in common practice and in the literature [1,2,3,4,5,6]. indeed, "a picture is worth a thousand words" has become a standard cliche in our culture. in the case of software, however, one must take great care that it is the correct thousand words that are being conveyed [5]. nonetheless, appropriate visualizations of software can be quite beneficial to programmers, especially when faced with program comprehension tasks. such tasks exist throughout the software life cycle (e.g., formal technical reviews, debugging, verification, reverse engineering) and in the classroom (e.g., students reading examples from the text or examples from the professor).the grasp (graphical representations of algorithms, structures, and processes) research project at auburn university seeks to develop tools and techniques for the effective use of graphical representations and visualizations of software. the overall goal of this research is to increase the efficiency of programmer comprehension and understanding of source code, and thereby decrease overall software cost. as an integral part of the research project, the grasp software engineering tool has been developed as a continuously evolving prototype. the emphasis of the tool to this point has been on visualizing program structure and complexity via the automatic generation of control structure diagrams (csds) and complexity profile graphs (cpgs) from ada source code [7]. the current release of grasp provides generation of csds and cpgs together with other program comprehension aids such as syntax coloring, typographical enhancements, and source code folding [8]. when coupled with an appropriate compilation system such as gnat, grasp becomes an integrated graphical development environment for ada 95, allowing users to edit, visualize, pretty-print, compile, link, execute and debug ada software.the grasp prototype for ada was first made available to the public in january 1996. since that time, thousands of copies of grasp have been downloaded via anonymous file transfer protocol (ftp) and the world wide web (www) from educational, government, military and commercial sites, both in the united states and abroad. when it was released to the public, grasp was also made available to users of the auburn university college of engineering computer network. grasp is now used extensively throughout the computer science and engineering curriculum at auburn university, in approximately three to five courses per quarter. t. dean hendrix james h. cross joe c. teate larry a. barowski karl s. mathias
chaining span-dependent jump instructions  the assembled length of a span-dependent jump instruction depends on the distance between the instruction and its target. such instructions are found on many computers and typically have two forms, long and short. we consider the problem of minimizing object program length for such machines by chaining together jumps with the same target. although the problem is np-complete in its most general form, several mildly restricted forms of the problem exist that are of practical importance and have efficient solutions.  bruce w. leverett thomas g. szymanski
gem: a tool for concurrency specification and verification  the gem model of concurrent computation is presented. each gem computation consists of a set of partially ordered events, and represents a particular concurrent execution. language primitives for concurrency, code segments, as well as concurrency problems may be described as logic formulae (restrictions) on the domain of possible gem computations. an event-oriented method of program verification is also presented. gem is unique in its ability to easily describe and reason about synchronization properties.  amy l. lansky susan s. owicki
a constructive algorithm for neural networks that generalize apl functions were designed to describe a constructive algorithm that synthesizes a neural network while optimizing its ability to generalize. algorithms are implemented in programs to discover networks of binary weights that assign unfamiliar, high-dimension binary patterns to their most similar classes. constructive algorithms that create networks are important for the design of classifiers based on array-processors made from fast two-level circuits. apl is an effective tool for the exposition of a constructive algorithm that can discover a minimal neural network. apl experts can benefit from being introduced to this interesting application and demonstration of the language's potential for describing array-based software or hardware. for constructing networks, algorithms for target switching and minimizing the overlap in the separation of training patterns have been used. typically, prototypes of constructive algorithms as commonly implemented with scalar-based procedural languages require hundreds of program statements. array-based formulations of similar constructive algorithms with functional style programming languages like apl and j are completed with a few brief functions. alvin surkan colin campbell
ada 95 conformity assessment - phil brashear on september 30, 1998, the ada resource association (ara) accepted responsibility to continue the activities of the ada joint program office (aipo), as part of transitioning ada support from government to private industry. the ara is promoting ada in a variety of areas. one primary responsibility is the continuation of the ada compiler validation process.the ara considered it necessary to distance the vendors that comprise the ara from the validation process itself. consequently, the ara is supporting the activities of the ada working group (jtc1/sc22/wg9) within the international organization for standards (iso) to standardize the existing validation processes. to become a standard, the ada validation terminology must be changed to match iso terminology (for example, validation is replaced with conformance assessment). the actual validation procedures supported by the ara are largely unchanged from those under the ajpo, with a few minor changes to reduce bureaucracy, improve reproducibility, and more easily integrate language maintenance. a number of independent organizations will work together to perform and oversee validations.the revised procedures are in use while waiting for the actual iso approval. to date, seven conformity assessments by two vendors have been performed using the new procedures and organization. randall brukardt steven deller joyce l. tokar
specialization tools and techniques for systematic optimization of system software  specialization has been recognized as a powerful technique for optimizing operating systems. however, specialization has not been broadly applied beyond the research community because current techniques based on manual specialization, are time-consuming and error-prone. the goal of the work described in this paper is to help operating system tuners perform specialization more easily. we have built a specialization toolkit that assists the major tasks of specializing operating systems. we demonstrate the effectiveness of the toolkit by applying it to three diverse operating system components. we show that using tools to assist specialization enables significant performance optimizations without error-prone manual modifications. our experience with the toolkit suggests new ways of designing systems that combine high performance and clean structure.  dylan mcnamee jonathan walpole calton pu crispin cowan charles krasic ashvin goel perry wagle charles consel gilles muller renauld marlet
automatic predicate abstraction of c programs  model checking has been widely successful in validating and debugging designs in the hardware and protocol domains. however, state-space explosion limits the applicability of model checking tools, so model checkers typically operate on abstractions of systems.  recently, there has been significant interest in applying model checking to software. for infinite-state systems like software, abstraction is even more critical. techniques for abstracting software are a prerequisite to making software model checking a reality.  we present the first algorithm to automatically construct a _predicate abstraction_ of programs written in an industrial programming language such as c, and its implementation in a tool --- c2bp. the c2bp tool is part of the slam toolkit, which uses a combination of predicate abstraction, model checking, symbolic reasoning, and iterative refinement to statically check temporal safety properties of programs.  predicate abstraction of software has many applications, including detecting program errors, synthesizing program invariants, and improving the precision of program analyses through predicate sensitivity. we discuss our experience applying the c2bp predicate abstraction tool to a variety of problems, ranging from checking that list-manipulating code preserves heap invariants to finding errors in windows nt device drivers.  thomas ball rupak majumdar todd millstein sriram k. rajamani
a coherent distributed file cache with directory write-behind  extensive caching is a key feature of the echo distributed file system. echo client machines maintain coherent caches of file and directory data and properties, with write-behind (delayed write-back) of all cached information. echo specifies ordering constraints on this write-behind, enabling applications to store and maintain consistent data structures in the file system even when crashes or network faults prevent some writes from being completed. in this paper we describe the echo cache's coherence and ordering semantics, show how they can improve the performance and consistency of applications, explain how they are implemented. we also discuss the general problem of reliably notifying applications and users when write-behind is lost; we addressed this problem as part of the echo design, but did not find a fully satisfactory solution.  timothy mann andrew birrell andy hisgen charles jerian garret swart
using java and the socket interface in teaching client/server programming in this poster, we present our experience developing java applets and applications to create a client/server system on the world wide web, and show how the product is used in upper-division computer science classes.the set of programs consist of a client and a server. the client program in the prototype is a java applet that is downloaded into the client machine and is executed in a user's web browser using the local memory, cpu and other resources. the server program in the prototype is a java application that runs on a web server all the time. the client and the server programs use the socket interface [ comer&amp;stevens; 96] as the communication protocol, and are able to transmit data back and forth successfully over the internet. figure 1 illustrates how the client and the server communicate over the socket interface.with the set of programs in place, students in the upper-division computer science classes, including _software engineering, databases systems, and distributed application development,_ are able to build their own software for the course projects, on top of the software prototypes.revision of a given set of java programs proves to be a better approach in learning client/server programming using java and sockets, compared to requiring students to create java programs from the scratch. andrew yang yael bachar
nested user interface components  nested user interface components combine the concepts of zooming user interfaces (zuis) with recursive nesting of active graphical user interface widgets. the resulting system of recursively nesting interface components has a number of desirable properties. the level of detail of the view of any widget component and its children, as well as the responsiveness of that component to the user's actions, can be tuned to the current visible size of that component on the screen.  we distinguish between the interaction style of a component, and the semantic result that it produces. only the latter is used to determine the geographic parameters for that component. in this way, very large and layered control problems can be presented to the user as a cohesive and readily navigable visual surface. it becomes straightforward to layout interaction semantics that are best handled by recursion, such as filters composed of nested expressions.  ken perlin jon meyer
further empirical studies of test effectiveness this paper reports on an empirical evaluation of the fault-detecting ability of two white-box software testing techniques: decision coverage (branch testing) and the all-uses data flow testing criterion. each subject program was tested using a very large number of randomly generated test sets. for each test set, the extent to which it satisfied the given testing criterion was measured and it was determined whether or not the test set detected a program fault. these data were used to explore the relationship between the coverage achieved by test sets and the likelihood that they will detect a fault.previous experiments of this nature have used relatively small subject programs and/or have used programs with seeded faults. in contrast, the subjects used here were eight versions of an antenna configuration program written for the european space agency, each consisting of over 10,000 lines of c code.for each of the subject programs studied, the likelihood of detecting a fault increased sharply as very high coverage levels were reached. thus, this data supports the belief that these testing techniques can be more effective than random testing. however, the magnitudes of the increases were rather inconsistent and it was difficult to achieve high coverage levels. phyllis g. frankl oleg iakounenko
portable, unobtrusive garbage collection for multiprocessor systems  we describe and prove the correctness of a new concurrent mark-and- sweep garbage collection algorithm. this algorithm derives from the classical on- the-fly algorithm from dijkstra et al. [9]. a distinguishing feature of our algorithm is that it supports multiprocessor environments where the registers of running processes are not readily accessible, without imposing any overhead on the elementary operations of loading a register or reading or initializing a field. furthermore our collector never blocks running mutator processes except possibly on requests for free memory; in particular, updating a field or creating or marking or sweeping a heap object does not involve system- dependent synchronization primitives such as locks. we also provide support for process creation and deletion, and for managing an extensible heap of variable-sized objects.  damien doligez georges gonthier
cyclic redundancy checks in ada95 among the many error detection techniques used in (tele)communications, the cyclic redundancy check (crc) is probably the most powerful one. roughly speaking the crc is merely a modulo-2 division of the data (bits) to be transmitted by some 'magical' polynomial known for its high error detection capabilities. crcs permit ensure that data transmitted over noisy media arrive intact.a common use of crcs among industrial partners in large software development to projects is to identify quickly shared files. this is the case in the aerospace industry for instance, at least in europe. crcs can be computed for any sort of file, be it a document file processed by a cots word processor, an image file, source code, a data file an executable file. the chances that two different files produce the same crc checksum are astronomically small. it is our experience it never happened since our involvement in the ariane 5 program, the new european launcher, six years ago.a major issue however is due to the many variations among crcs algorithms. for instance, most unix platforms provide a crc checksum command, but few of them compute the same crc checksum for a given file (obviously, the file format being identical). this issue has been addressed by the x/open standardisation committee in charge of the unix specification. the so-called x/open single unix specification [1], nicknamed unix95, contains a precise description of a crc algorithm, which fully complies with the posix one [2]. as unix vendors are actually upgrading their product to become unix95 branded, one may expect these variations will disappear in the near future, in the unix world at least.in this paper we present an implementation of the posix/unix95 crc algorithm in ada95. our purpose is three-fold. firstly we want to provide standard source code that can be recompiled on any platform, unix-like or not, and be reused by other projects. secondly we want the implementation to be scalable, typically from a 16-bit crc ckecksum up to (at least) a 64-bit crc ckecksum, as 64 bit cpus become available on the market. the scalability goal is achieved by designing a generic implementation, the posix/unix95 crc being a specific 32-bit of instantiation of it. the implementation is based on previous well designed and optimized work done in c [3], the purpose here is not to reinvent the wheel but to make it generic and scalable. thirdly, the implementation illustrates some of the of new features of the ada95 language: shifting and rotating procedures, modular types, aliased accesses, generic formal package, child packages and exception information, to name a few. guido duerinckx
a runtime representation for ada variables and types  the type and subtype facilities of the ada programming language permit some subtype information to be determined dynamically. this subtype information requires a runtime representation, and its dynamic nature influences the representation of variables. in this paper, we first review ada's types and subtypes to identify some of those aspects which affect runtime representation. we then present the particular representation scheme which is used in the charrette ada implementation. the scheme is straightforward and consistent in that a variable is represented the same way independently of where it appears, whether it is on the stack, on the heap, or a component of another variable. the design treats ada's discriminants and discriminant constraints as a form of parameterized types, where the parameterization permits different instances of a type to have different variants and different sizes for array fields. composition of such parameterized types is supported. we explain how several ada operations are handled by our particular representation. we briefly discuss some alternative approaches to ada representation, comparing them to our design.  andy hisgen david alex lamb jonathan rosenberg mark sherman
generation of multi-formalism state-space analysis tools as software evolves from early architectural sketches to final code, a variety of representations are appropriate. moreover, at most points in development, different portions of a software system are at different stages in development, and consequently in different representations. state-space analysis techniques (reachability analysis, model checking, simulation, etc.) have been developed for several representations of concurrent systems, but each tool or technique has typically been targeted to a single design or program notation.we describe an approach to constructing space analysis tools using a core set of basic representations and components. such a tool generation approach differs from translation to a common formalism. we need not map every supported design formalism to a single internal form that completely captures the original semantics; rather, a shared "inframodel" represents only the essential information for interpretation by tool components that can be customized to reflect the semantics of each formalism. this results in more natural and compact internal representations, and more efficient analysis, than a purely translational approach.we illustrate the approach by applying the prototype tool to a small example problem, coordination of access to a coffee machine. the coffee machine is controlled by an ada program, and the protocol of human users is modeled with petri nets. nets and process graph models are represented in the common internal form, and their composite behavior is analyzed by the prototype tool. mauro pezzè michal young
the structure of cedar  this paper presents an overview of the cedar programming environment, focusing primarily on its overall structure: the major components of cedar and the way they are organized. cedar supports the development of programs written in a single programming language, also called cedar. we will emphasize the extent to which the cedar language, with runtime support, has influenced the organization, comprehensibility, and stability of cedar.  produced in the computer science laboratory (csl) at the xerox palo alto research center, cedar is a research environment supporting the development and use of experimental programs, emphasizing office information and personal information management applications. although it was clear that some unsolved problems would be addressed, the intent was to combine well-understood methods and technologies to exploit a new generation of high-performance personal computers, including the xerox 1132 (dorado) and xerox 1108 (dandelion).  daniel c. swinehart polle t. zellweger robert b. hagmann
detection and recovery of endangered variables caused by instruction scheduling  instruction scheduling re-orders and interleaves instruction sequences from different source statements. this impacts the task of a symbolic debugger, which attempts to present the user a picture of program execution that matches the source program. at a breakpoint b, if the value in the run-time location of a variable v may not correspond to the value the user expects v to have, then this variable is endangered at b. this paper describes an approach to detecting and recovering endangered variables caused by instruction scheduling. we measure the effects of instruction scheduling on a symbolic debugger's ability to recover source values at a breakpoint. this paper reports measurements for three c programs from the spec suite and a collection of programs from the numerical recipes, which have been compiled with a variant of a commercial c compiler.  ali-reza adl-tabatabai thomas gross
spritely nfs: experiments with cache-consistency protocols  file caching is essential to good performance in a distributed system, especially as processor speeds and memory sizes continue to improve rapidly while disk latencies do not. stateless-server systems, such as nfs, cannot properly manage client file caches. stateful systems, such as sprite, can use explicit cache consistency protocols to improve both cache consistency and overall performance.  by modifying nfs to use the sprite cache consistency protocols, we isolate the effects of the consistency mechanism from the other features of sprite. we find dramatic improvements on some, although not all, benchmarks, suggesting that an explicit cache consistency protocol is necessary for both correctness and good performance.  v. srinivasan j. mogul
structured editor support for modularity and data abstraction  language facilities for data abstraction and modularity have traditionally involved extensions to the declaratory syntax of the languages. batch compiler technology forces the separation of the editing of this syntax from its being checked by the compiler, making programming more difficult.  we discuss an alternate method of supporting such features in a language-based structured editor. rather than adding syntax to the language, we simply use the editor to restrict uses of names. in order to specify the restrictions, we provide a language-independent notion of names and scopes in our abstract syntax tree.  michael caplinger