waashk/acm huggingface dataset:
evaluating and comparing software metrics in the software engineering laboratory  there has appeared in the literature a great number of metrics that attempt to measure the effort or complexity in developing and understanding software(1). there have also been several attempts to independently validate these measures on data from different organizations gathered by different people(2). these metrics have many purposes. they can be used to evaluate the software development process or the software product. they can be used to estimate the cost and quality of the product. they can also be used during development and evolution of the software to monitor the stability and quality of the product.  among the most popular metrics have been the software science metrics of halstead, and the cyclomatic complexity metric of mccabe. one question is whether these metrics actually measure such things as effort and complexity. one measure of effort may be the time required to produce a product. one measure of complexity might be the number of errors made during the development of a product. a second question is how these metrics compare with standard size measures, such as the number of source lines or the number of executable statements, i.e., do they do a better job of predicting the effort or the number of errors? lastly, how do these metrics relate to each other?  victor r. basili tsai-yun phillips
applying gqm in an industrial software factory  goal/question/metric gqm) is a paradigm for the systematic definition, establishment, and exploitation of measurement programs supporting the quantitative evaluation of softare processes and products. although gqm is a quite well-known method, detailed guidelines for establishing a gqm program in an industrial environment are still limited. also, there are few reported experiences on the application of gqm to industrial cases. finally, the technological support for gqm is still inadequate. this article describes the experience we have gained in applying gqm at digital laboratries in italy. the procedures, experiences, and technology that have been employed in this study are largely reusable by other industrial organizations willing to introduce a gqm-based measurement program in their development environments.  alfonso fuggetta luigi lavazza sandro morasca stefano cinti giandomenico oldano elena orazi
recent developments in isi-interlisp  this paper reports on recent developments of the isi- interlisp implementation of interlisp on a vax computer. isi-interlisp currently runs under unix, specifically the berkeley vm/unix and vms operating systems. particular attention is paid to the current status of the implementation and the growing pains experienced in the last few years. included is a discussion of the conversion from unix to vax/vms, recent modifications and improvements, current limitations, and projected goals. since much of the recent effort has concerned performance tuning, our observations on this activity are included. isi-interlisp, formerly known as interlisp-vax, was reported in 1982 acm symposium on lisp and functional programming, august 1982 [1]. experiences and recommendations since the 1982 lisp conference are presented.  raymond l. bates david dyer mark feber
nonce functions  data, functions, and operators exist in divers current apl systems in primitive, derived, and defined forms. only data primitives occur in an extended literal form, which can be quite complex. this paper introduces a form of function literal, subsequently extended to include operators. lexical scope is restricted to the minimum to achieve perspicuousness and syntactic predictability. the short expressions which result form convenient, explicit representations of some common trivial functions. they can indirectly simulate trivial operators. nonce operators can simulate syntactic entities, which have been called transforms, that produce operators. the trade-offs between extra key strokes and symbol clutter are discussed.  j. philip benkard
unification based fp interpreters  a specification is given for the functional programming language fp using an attribute grammar formalism that defines a message passing protocol. derivations in the grammar specify the complete evaluation of an fp program. the message passing provides a functional type checking capability. to avoid the overhead associated with message passing, the grammar is designed so that each fp primitive function and functional form receives and transmits a single message during the compilation. the language specification provides the framework for the construction of two fp interpreters.  an interpreter using an innermost first evaluation strategy, the standard evaluation approach for functional composition, is implemented in prolog. the rules of the language specification are directly translated into prolog grammar rules. the message passing and type checking are achieved using the unification of variables in the prolog grammar rules.  the innermost first strategy requires the compilation and evaluation of the subfunctions and functional forms that comprise an fp function. a second interpreter, using the parallel logic programming language parlog, was constructed to incorporate eager evaluation into the analysis of an fp function. eager evaluation is accomplished by transmitting partial results (incompletely constructed lists) throughout the evaluation structure. whenever the partial results contain sufficient information to determine a value, these are used as input to the subfunctions that comprise the fp function being evaluated. adding eager evaluation alters the degree of error preservation and requires a modification of the defintion of fp.  chris fickert thomas sudkamp
back to the future (panel session): is worse (still) better?  functional programming, ai, patterns, oo, structured programming - they were promising, and yet they seem to have failed to deliver. did we lose interest too soon? is the best too good for our industry? is there "a" best for our industry or is our endless search for the silver bullet driving us? do we want the "best" to (again) be a popular goal? how?  martine devos richard p. gabriel james o. coplien t. j. d'hondt jutta eckstein brian foote kevlin henney alan o'callaghan
a functional shell  one of the best features of the standard unix shell is the use of pipes to compose programs. a c language derivative is used for more complex program combinations involving looping or branching. this paper presents an alternative shell language based on natural extensions of the pipe concept.  "structured data streams" are introduced as a means of expressing potentially concurrent processing, and "labelled data streams" serve to route data to one of a pool of programs. these complex data streams are hooked together with functional operators much as simple data streams are hooked together with pipes. a generalized notion of "powers" provides for repetition of programs and also for systems that take an arbitrary number of input streams. this provides a uniform way of building complex tools from simple ones, as advocated by kernighan and plauger [8]. a major advantage of this new shell language is its program algebra, which facilitates system verification and analysis.  jon shultis
experiences using the parascope editor: an interactive parallel programming tool  the parascope editor is an interactive parallel programming tool that assists knowledgeable users in developing scientific fortran programs. it displays the results of sophisticated program analyses, provides a set of powerful interactive transformations, and supports program editing. this paper summarizes experiences of scientific programmers and tool designers using the parascope editor. we evaluate existing features and describe enhancements in three key areas: user interface, analysis, and transformation. many existing features prove crucial to successful program parallelization. they include interprocedural array side-effect analysis and program and dependence view filtering. desirable functionality includes improved program navigation based on performance estimation, incorporating user assertions in analysis and more guidance in selecting transformations. these results offer insights for the authors of a variety of programming tools and parallelizing compilers.  mary w. hall timothy j. harvey ken kennedy nathaniel mcintosh kathryn s. mckinley jeffrey d. oldham michael h. paleczny gerald roth
debugging via run-time type checking java programmers have the security of knowing that errors like out-of-bounds array indexes or attempts to dereference a null pointer will be detected and reported at run time. c and c++ programmers count on tools like purify to achieve a similar level of confidence. the run-time checks provided by purify have proved to be extremely useful to programmers in debugging their programs.java also provides security via its strong type system. for example: there are no union types in java, so it is not possible for a program to write into a field of one type and then access that value via a field of a different type. only very restricted kinds of casting are allowed; for example, it is not possible to treat a pointer as if it were an integer or vice versa. when an object is down-cast to a subtype, a run-time check will be performed to ensure that the actual type of the object is consistent with the cast.however, tools like purify do not provide similar checks for c/c++ programs. this research involves the design and implementation of a tool to provide new kinds of run-time checks based on type information. that is, the goal of the tool is to help c/c++ programmers find errors in their programs that manifest themselves as bad run-time types, in the same way that purify helps programmers find errors in their programs that manifest themselves as bad run-time memory accesses.the basic idea is to associate a run-time type with every piece of data. whenever data is used by some operation, a check is performed to ensure that its run-time type is consistent with the type expected by the operation. for example, when a pointer is dereferenced, its run-time type must be "pointer" (not "int", "float", "uninitialized", etc). when an integer multiplication is performed, the operands' run-time types must be "int" (not "pointer", "float", "uninitialized", etc). susan horwitz
aslantest: a symbolic execution tool for testing aslan formal specifications  this paper introduces aslantest, a symbolic execution tool for the formal specification language aslan. aslan is a state-based specification language built on first-order predicate calculus with equality. aslantest animates aslan specifications and enables users to interactively run specific test cases or symbolically execute the specification. testing the formal specifications early in the software life cycle allows one to assure a reliable system that also provides the desired functionality.  jeffrey douglas richard a. kemmerer
arcturus: a prototype advanced ada@@@@ programming environment  the arcturus system demonstrates several important principles that will characterize advanced ada programming support environments. these include conceptual simplicity, tight coupling of tools, and effective command and editing concepts. arcturus supports interactive program development and permits the combined use of interpretive and compiled execution. arcturus is not complete however, as practical, mature environments for ada must also support the development, analysis, testing, and debugging of concurrent programs. these issues are currently being explored. arcturus, therefore is a platform for experimental exploration of key programming environment issues. this paper focuses primarily on the current system, describing and illustrating some of its components, while issues less fully developed are more briefly described.  thomas a. standish richard n. taylor
reuse dimensions  in recent years, there have been much publications on reuse. in order to bet an overview of the whole field and also a good impression of the state of the reuse art, we studied reuse literature of the last few years. as basis for comparison, we classified literature according to four (more or less orthogonal) dimensions, based on the actions and knowledge of the reuser, i.e. the software engineer. the dimensions are: actions to be taken to get an existing reusable item; knowledge to be applied to find an existing reusable item; actions to be taken to build the complete system needed; knowledge to be applied to get the complete system needed.  the survey shows that research on reuse from the viewpoint of needed system, receives far less attention than research from the viewpoint of reusable artifacts. we expect reuse to live up to its promise if this topic is addressed was well.  liesbeth dusink jan van katwijk
link-time optimization of address calculation on a 64-bit architecture  compilers for new machines with 64-bit addresses must generate code that works when the memory used by the program is large. procedures and global variables are accessed indirectly via global address tables, and calling conventions include code to establish the addressability of the appropriate tables. in the common case of a program that does not require a lot of memory, all of this can be simplified considerably, with a corresponding reduction in program size and execution time.  we have used our link-time code modification system om to perform program transformations related to global address use on the alpha axp. though simple, many of these arewhole- program optimizations that can be done only when we can see the entire program at once, so link-time is an ideal occasion to perform them.  this paper describes the optimizations performed and shows their effects on program size and performance. relatively modest transformations, possible without moving code, improve the performance of spec benchmarks by an average of 1.5%. more ambitious transformations, requiring an understanding of program structure that is thorough but not difficult at link- time, can do even better, reducing program size by 10% or more, and improving performance by an average of 3.8%.  even a program compiled monolithically with interprocedural optimization can benefit nearly as much from this technique, if it contains statically-linked pre-compiled library code. when the benchmark sources were compiled in this way, we were still able to improve their performance by 1.35% with the modest transformations and 3.4% with the ambitious transformations.  amitabh srivastava david w. wall
magellan: multiway hardware-software partitioning and scheduling for latency minimization of hierarchical control-dataflow task graphs  _the paper presents magellan, a heuristic technique for mapping hierarchical control-dataflow task graph specifications on heterogeneous architecture templates. the architecture can consist of multiple hardware and software processing elements as specified by the user. the objective of the technique is to minimize the worst case latency of the task graph subject to the area constraints on the architecture. the technique uses an iterative approach consisting of closely linked hardware-software partitioner and scheduler. both the partitioner and scheduler operate on the task graph in a hierarchical top down manner. the technique optimizes deterministic loop constructs by applying clustering, unrolling and pipelining. the technique considers speculative execution for conditional constructs. the number of actual hardware/software implementations of a function in the task graph are also optimized by the technique. the effectiveness of the technique is demonstrated by a case study of an image compression algorithm._  karam s. chatha ranga vemuri
an application of software science to the quantitative measurement of code quality  the error rate of a software application may function as a measure of code quality. a methodology has been developed which allows for the accurate prediction of the error rate and hence code quality prior to an application's release.  many factors were considered which could conceivably be related to the error rate. these factors were divided into two categories: those factors which vary with time, and those factors which do not vary with time. factors which vary with time were termed environmental factors and included such items as: number of users, errors submitted to date, etc. factors which do not vary with time were termed internal factors and included halstead metrics, mccabe metrics and lines of code.  farid a. naib
delivering the goods with lisp  lisp has long had a reputation for the efficacy of its development environment. it is used in academia and by some r&amp;d; groups in industry; and, compared with conventional languages, it is hardly ever used in real applications in the real world. it will always be perceived as a rather arcane esoteric language if it does not successfully leave the ivory towers and start delivering the goods where it really matters \---at the sharp end in industry.  richard barber george imlah
wcl: delivering efficient common lisp applications under unix  common lisp implementations for unix have traditionally provided a rich development environment at the expense of an inefficient delivery environment. the goal of wcl is to allow hundreds of lisp applications to be realistically available at once, while allowing several of them to run concurrently. wcl accomplishes this by providing common lisp as a unix shared library that can be linked with lisp and c code to produce efficient applications. for example, the executable for a lisp version of the canonical "hello world!" program requires only 40k bytes under sunos 4.1 for sparc. wcl also supports a full development environment, including dynamic file loading and debugging. a modified version of gdb, the gnu debugger, is used to debug wcl programs, providing support for mixed language debugging. the techniques used in wcl should also be applicable to other high-level languages that allow runtime mappings from names to objects.  wade hennessey
optimizing an ansi c interpreter with superoperators  this paper introduces superoperators, an optimization technique for bytecoded interpreters. superoperators are virtual machine operations automatically synthesized from smaller operations to avoid costly per-operation overheads. superoperators decrease executable size and can double or triple the speed of interpreted programs. the paper describes a simple and effective heuristic for inferring powerful superoperators from the usage patterns of simple operators.  the paper describes the design and implementation of a hybrid translator/interpreter that employs superoperators. from a specification of the superoperators (either automatically inferred or manually chosen), the system builds an efficient implementation of the virtual machine in assembly language. the system is easily retargetable and currently runs on the mips r3000 and the sparc.  todd a. proebsting
software engineering provisioning process  the main theme of the 8th international conference on software engineering is the "establishment of a better understanding of the software process and its improvement through the provision of better models, methods and tools." this paper addresses the second half of this theme by defining the issues involved with making strategic improvements to environments and suggesting a process for "provisioning" (or providing) better computer-aided software engineering methods and tools.  the paper focuses primarily on the process for transforming existing, large to very large scale software development and support environments into conceptual "software factories." to achieve this goal, arguments are made for strategically planning and developing well architected, modifiable software engineering environments. this is considered a prerequisite to effective "provisioning" of new and improved methods and tools.  taken as a whole, the paper should be useful to software developers, tool providers and major software buyers alike. through typical environment evolution scenarios and concrete examples, many useful suggestions are provided to each of these players on how they can assist in the software engineering improvement process.  john h. manley
the computer construction of weaving designs weaving is the art of forming a fabric by interlacing threads at right angles and is performed on a frame called a loom. the threads at right angles to the weaver are the warp threads, and the threads parallel to the weaver and which are inserted between the warp threads are the weft threads. the warp threads are alternately raised and lowered to create a shed through which the weft thread is inserted. they are fastened to a warp roller at the back of the loom, pass over a back beam and through the eyes of vertical wires called heddles, and then through reeds which help keep them parallel and in the proper sequence. the woven cloth passes over a front beam and is then wound onto a cloth roller. each row of heddles is attached to a harness, and there may be two, four, eight or more harnesses. each warp thread passes through a heddle on any one of the harnesses. the harnesses are raised and lowered by treadles which are worked by the fingers on a table loom and by the feet on a foot loom. harnesses may be tied together so that more than one may be operated by the same treadle. as a group of warp threads is raised or lowered by the treddles, the shuttle with the weft thread is inserted into the shed between the two groups of threads. keith smillie
dynascope: a tool for program directing  this paper introduces program directing, a new way of program interaction. directing enables one program, the director, to monitor and to control another program, the executor. one important application of program directing is human interaction with complex computer simulations.  the dynascope programming environment is designed specifically to support directing in traditional, compiled languages. it provides a framework and building blocks for easy construction of sophisticated directors. directors are regular programs that perform the directing of executors through dynascope primitives. dynascope is built around the concept of the execution stream which provides a complete description of the executor's computational behavior. the source code of executors requires no changes in order to be subjected to directing.  this paper gives an overview of the dynascope system. sample applications are presented: debugging register allocation, animation of procedure calls, and a complex artificial life simulation. the performance of dynascope is illustrated by real time measurements.  rok sosic
an approach to the classification of domain models in support of analogical reuse  this paper presents an approach to classify domain models in order to facilitate reuse through analogy. domain analysis plays a critical role for systematic reuse, but domain analysis is difficult to perform, especially for new application areas. analogical approach to reuse can support the domain analysis process by providing software products in a different but analogous domain. in order to achieve this goal, domain models need to be classified. this paper proposes a classification method for domain models. the method is an integration of the enumerative hierarchy and faceted scheme. the classification approach can help the domain analyst to locate an analogous domain to perform the modeling and analysis process. moreover, the approach is more flexible and more descriptive than conventional classification methods.  chung-horng lung joseph e. urban