waashk/acm huggingface dataset:
a collection of software tools for analyzing designs of concurrent software systems  we present results from a research project to investigate the feasibility of software tools for analyzing designs of software systems. such analysis would help the software developer to assess the acceptability of designs before the development of the software moves from the design phase into the implementation phase. if this could be done, futile implementation efforts based on faulty designs could be avoided.  we have constructed a language for expressing designs of sequential and concurrent software systems, and software tools to analyze these designs. our analysis tools derive behavior information, in terms of reachable states or possible sequences of significant events, from system descriptions in a variety of ways. by means of controlled human-factors experiments, we have determined that our analysis tools and techniques are indeed useful, to varying extents, in helping people to understand designs and find flaws in them.  allan m. stavely david c. becker susan p. orr gregory b. titus
automated support for software development with frameworks  this document presents some of the results of an industrial research project on automation of software development. the project's objective is to improve productivity and quality of software development. we see software development based on frameworks and libraries of prefabricated components as a step in this direction. an adequate development style consists of two complementary activities: the creation of frameworks and new components for functionality not available and the composition and configuration of existing components.  just providing adequate frameworks and components does not necessarily yield automation and efficiency of software development. we developed the concept of relations between software components as a foundation for abstraction, reuse and automatic code generation for component interrelationship. furthermore we suggest to supplement frameworks with an active cookbook consisting of active recipes which guide the software developer in the use of framework elements.  in this paper our concept of using relations among software components is presented and the active cookbook is illustrated as a means for developer guidance. we created a prototype to demonstrate these concepts.  albert schappert peter sommerlad wolfgang pree
active design reviews: principles and practices  although many new software design techniques have emerged in the past 15 years, there have been few changes to the procedures for reviewing the designs produced using these techniques. this paper describes an improved technique, based on the following ideas, for reviewing designs.  the efforts of each reviewer should be focussed on those aspects of the design that suit his experience and expertise.  the characteristics of the reviewers needed should be explicitly specified before reviewers are selected.  reviewers should be asked to make positive assertions about the design rather than simply allowed to point out defects.  the designers pose questions to the reviewers, rather than vice versa. these questions are posed on a set of questionnaires that requires careful study of some aspect of the design.  interaction between designers and reviewers occurs in small meetings involving 2 - 4 people rather than meetings of large groups.  illustrations of these ideas drawn from the application of active design reviews to the naval research laboratory's software cost reduction project are included.  david l. parnas david m. weiss
aladdin/lamp: configuration management tools for distributed computer control systems  the problem of the automation of the development of distributed software configuration (dsc) in the distributed computer control systems (dccs) is discussed. the present paper deals with the building technology of the organisation of the interactions environment of applicational programs through the constructions like "information transport port" (itp); on the basis of the dccs structural model the system architects' language aladdin is developed. it is designated for the control of itp work and for the linkage of dsc. the aladdin/lamp software development system is described.  a. pakstas
experiments with prolog design descriptions and tools in caede: an iconic design environment for mutltitasking, embedded systems  we report on experiments with prolog design descriptions and tools in caede (carleton embedded system design environment), an experimental, iconic design environment for multitasking, embedded systems. the philosophy of caede is to enter structural and temporal design information iconically, via a graphics interface, to serve as the basis for design analysis and skeleton code generation, and then to enter, under control of the iconic interface, program "strips" to fill in the functional gaps in the skeleton code. the iconic information is converted automatically into a prolog design data base of facts and rules. caede aims to support incremental design and to be incrementally extensible. in the current implementation of caede, which runs on a sun workstation supporting design for ada, the iconic interface is limited to structural design. here we describe the prolog side of our research, covering the nature of the facts produced from the iconic input by the current implementation and their use by experimental prolog tools for structural analysis, temporal analysis and ada code generation. the aim is to show how prolog is contributing to the framework of a powerful, extensible design environment.  r. j. a. buhr c. m. woodside g. m. karam k. van der loo d. g. lewis
geometric data of cross-sections of beams  this paper describes a program which calculates the geometrical characteristic values of cross- sections of beams with complex shapes (bars or thin-walled profiles with any number of holes in the profiles).  after a short introduction describing the calculations involved for moments of area, we will introduce the capabilities of every component of this program and we will make a survey of the whole system via flow chart.  at the end of the paper we will summarize the main features of the program and mention some possible extensions.  holger besier
tool interfaces in integrated project support environments  it is generally agreed that to meet these objectives and achieve integration an ipse should be built round a kernel or infrastructure of common services.  coherence is then achieved if the infrastructure provides services to tools which relieve the toolwriter of the need to code, for example, user interface handling. not only does this aid uniformity, but of course it also offers economic leverage.  control of the environment resides in the kernel and it is not possible for tools to ignore the controls and prejudice the integrity of the project data.  sharing is achieved because the project data and its structure reside in the database which is under the control of the kernel.  early efforts to build such an ipse were based on the stoneman model, where the kernel was the kapse. the crucial interface in this architecture is the kapse interface, which offers services to all tools. we did not sufficiently realise, however, that there is a major economic problem in designing a new interface from scratch. all tools which are to be used in an environment must, by definition, conform to this interface definition. this means that all the tools have to be specially written to use the new interface, and it became apparent that no single organisation could or should expect to provide a complete new tool kit in this way. rather one wants an open market in software tools, in the same way that it is hoped ada will lead to an open market in software components. the more recent history of ipse efforts, therefore, has been an attempt to resolve the conflict between the desire for integration and the need for environments to accept a wide range of tools from various sources.  perhaps the most ambitious project taking this approach is aspect, a project within the uk alvey programme, which is currently delivering prototypes for evaluation. aspect aims to provide a highly functional open tool interface covering coherence, control and sharing. it does this by treating the open tool interface as a special case of an adaptable interface which provides user-defined views of the underlying kernel. this approach depends heavily on the notions of views developed in the relational database world.  a. hall
the role of parellelism in file organization  the role parallelism can play in searching large collections of data is investigated. three primary methods of making use of parallelism are discussed. the first is the traditional use of parallelism in searching, that is to speed up the search operation. the second was of parallelism discussed in the paper is to extend the facilities of a file organization, e.g. the ability of the operation to handle insertions. the last use of parallelism investigated is the use of the parallel processing resource to improve the quality of the search. examples of each of the three methods are provided with simulation results illustrating the impact of parallelism.  leslie l. miller tyne liang
an environment for literate smalltalk programming  the programming environment described in this paper is an adaptation of donald knuth's concept of literate programming, applied to smalltalk programs. the environment provides a multi-media document production system including media for smalltalk class and method definitions.  there are two outputs from the system. the first output is a document which contains general descriptions and discussions intermixed with precise definitions of program fragments, test inputs and test results. the second output consists of compiled smalltalk programs installed and ready for execution.  the main idea was to produce program documentation that was just as interesting and fascinating to read as ordinary literature. our experience showed an added benefit, namely that the literate programming environment was an active aid in the problem solving process. the simultaneous programming and documentation lead to significantly improved quality of both programs and documentation.  t. reenskaug a. l. skaar
specification of abstract data types in modula  the programming language modula is extended to permit the formal specification of the structure and functional capabilities of modules. this makes true hierarchical programming possible in modula by allowing programmers of higher level parts of a system to ignore completely the internal structure of lower level modules and to rely entirely on the specifications of the capabilities of these modules. an example is included to illustrate this technique. we show that our specification mechanisms are sufficiently powerful to support formal verification rules for modules that have disjoint representations for abstract objects.  george w. ernst william f. ogden
compiler optimizations for eliminating barrier synchronization  this paper presents novel compiler optimizations for reducing synchronization overhead in compiler-parallelized scientific codes. a hybrid programming model is employed to combine the flexibility of the fork-join model with the precision and power of the single-program, multiple data (spmd) model. by exploiting compile-time computation partitions, communication analysis can eliminate barrier synchronization or replace it with less expensive forms of synchronization. we show computation partitions and data communication can be represented as systems of symbolic linear inequalities for high flexibility and precision. these optimizations has been implemented in the stanford suif compiler. we extensively evaluate their performance using standard benchmark suites. experimental results show barrier synchronization is reduced 29% on average and by several orders of magnitude for certain programs.  chau-wen tseng
features of the gnu ada runtime library  the gnu ada runtime library (gnarl) is being developed to support ada 9x tasking for the gnu nyu ada translator (gnat). together, they form a portable, freely distributable ada 9x translation system. gnarl and gnat communicate through a well-defined procedural interface, facilitating their independent development.  among the design goals of this translation system are portability, interoperability with other languages (in particular c), efficiency, and user extensibility. this paper provides an overview of how the gnarl supports these goals.  e. w. giering frank mueller t. p. baker
writing a compilers compiler in apl this paper describes the special capabilities of apl2 for the construction of compilers and translator writing systems (tws). to that purpose, a tws has been written in apl2, which takes as input a complete description of a language including an attribute grammar, in extended backus normal form, and the semantic function associated to each rule of the grammar, written in apl2. the output of the tws is a compiler, generated directly inside the workspace and ready to compile source code written in the provided language. enrique alfonseca
nested arrays and operators: some issues in depth  following the new direction taken by the iso standards committee meeting in palo alto, during august, 1991, an extended apl standard is considered using a nested array basis with particular features from ibm's apl2 program product. apl2 develops from iso apl with the relaxation of two early scalar constraints. enclose, disclose, and each are derived from properties of bracket indexing and scalar conformance. identities connect these new operations with the structural operators. decisions must be made on what features from other systems, presently implemented or not, should be added to the nested array foundation. candidates for inclusion are rank and depth operators and various sorts of program definable data types. comparisons are made between constructs, and tentative conclusions are advanced.  j. philip benkard
adapting programming languages technologies for finite-state verification program verification and program transformation are two research areas that have different goals. program verification aims to increase confidence in software through the use of formal methods and systematic testing. program transformation rearranges the structure of programs to increase their efficiency or to make them more amenable to some other form of processing. despite being funded under different nsf awards from the software engineering and languages program on the two different areas above the authors are collaborating to apply results from both awards to develop a set of tools, called bandera, for transforming java programs into a form that is amenable to verification using existing model checking tools. matthew b. dwyer john hatcliff
prototyping as a tool in the specification of user requirements  one of the major problems in developing new computer applications is specifying the user's requirements such that the requirements specification is correct, complete and unambiguous. although prototyping is often considered too expensive, correcting ambiguities and misunderstandings at the specification stage is significantly cheaper than correcting a system after it has gone into production. this paper describes how a prototype was used to help specify the requirements of a computer system to manage and control a semiconductor processing facility. the cost of developing and running the prototype was less than 10% of the total software development cost.  hassan gomaa douglas b.h. scott
the gnu ada runtime library (gnarl)  the gnu ada runtime library (gnarl) is an implementation of ada 9x tasking. it is designed to support the gnu-nyu ada translator (gnat), and is part of the gnat distribution. this report describes the design of the interface which gnarl presents to compiler- generated code, some of the alternatives considered, and the motivation for choosing the current design. it also discusses the gnarl implementation, how it is intended to be layered over the services of an off-the-shelf commercial operating system, and the expected compiler translation of various ada 9x tasking constructs.  e. w. giering t. p. baker
add finalization with its tagged types and appropriate dynamic binding facilities, ada95 has become a mighty language. virtually ad libidum, you can add new components to given types of a class. this seems to imply some kind of arbitrariness in the choice of the starting point of a type hierarchy (the root of a class). however, this arbitrariness is only a seeming one and you rather have to exercise utmost care in choosing the root lest you might run into troubles at the end. this fact is highlighted by the following problem about controlled types i found some time ago in the ada internet forum chat@gnat.com, which i thought might be of common interest. christoph grein
a proof system for communicating sequential processes  an axiomatic proof system is presented for proving partial correctness and absence of deadlock (and failure) of communicating sequential processes. the key (meta) rule introduces cooperation between proofs, a new concept needed to deal with proofs about synchronization by message passing. csp's new convention for distributed termination of loops is dealt with. applications of the method involve correctness proofs for two algorithms, one for distributed partitioning of sets, the other for distributed computation of the greatest common divisor of n numbers.  krzysztof r. apt nissim and willem p. de roever
control flow analysis in scheme  traditional flow analysis techniques, such as the ones typically employed by optimizing fortran compilers, do not work for scheme-like languages. this paper presents a flow analysis technique \--- control flow analysis \\--- which is applicable to scheme-like languages. as a demonstration application, the information gathered by control flow analysis is used to perform a traditional flow analysis problem, induction variable elimination. extensions and limitations are discussed.  the techniques presented in this paper are backed up by working code. they are applicable not only to scheme, but also to related languages, such as common lisp and ml.  o. shivers
when to stop testing and start using software?  during the last decade, numerous studies have been undertaken to quantify the failure process of large scale software systems. (see for example, references 1-12.) an important objective of these studies is to predict software performance and use the information for decision making. an important decision of practical concern is the determination of the amount of time that should be spent in testing. this decision of course will depend on the model used for describing the failure phenomenon and the criterion used for determining system readiness.  in this paper we present a cost model based on the time dependent fault detection rate model of goel and okumoto (4,5) and describe a policy that yields the optimal value of test time t.  amrit l. goel kazuhira okumoto
the coming-of-age of software architecture research  over the past decade, software architecture research has emerged as the principled study of the overall structure of software systems, especially the relations among subsystems and components. from its roots in qualitative descriptions of useful system organizations, software architecture has matured to encompass broad explorations of notations, tools, and analysis techniques. whereas initially the research area interpreted software practice, it now offers concrete guidance for complex software design and development.  we can understand the evolution and prospects of software architecture research by examining the research paradigms used to establish its results. these are, for the most part, the paradigms of software engineering. we advance our fundamental understanding by posing research questions of several kinds and applying appropriate research techniques, which differ from one type of problem to another, yield correspondingly different kinds of results, and require different methods of validation. unfortunately, these paradigms are not recognized explicitly and are often not carried out correctly; indeed not all are consistently accepted as valid.  this retrospective on a decade-plus of software architecture research examines the maturation of the software architecture research area by tracing the types of research questions and techniques used at various stages. we will see how early qualitative results set the stage for later precision, formality, and automation and how results build up over time. this generates advice to the field and projections about future impact.  mary shaw
programming cost estimate: is it reasonable?  a basic concern when considering a programming cost estimate is its reasonableness. a statistical examination of over thirty completed products was conducted, using least square error methods, to develop an improved method for establishing a central value and an acceptable range of values for programming product cost estimates. eight variables associated with the coding process, such as the number of lines of new and modified basic assembler language and number of new modules, were found to be useful in developing reasonableness equations. using regression equations developed from the variables, we developed reasonableness tests that compare the estimate prepared by the developer to the actual development effort applied to previous products.  insight also was gained about programmer productivity, the quality of code estimations, and the optimum number of lines of code per module.  estimates are usually based on the experience of the past. but whatever method is used, the main consideration is the error of estimate associated with that method. the basic question about any estimate is: how good is it?  the current state of the art of the cost estimating of software projects evolved from the works of walverton1 attempting to correlate the size of effort in person-months with the size of the product expressed in thousand lines of source code (kloc). large dispersion of data forced walston and felix2 to take into account additional variables such as programmer experience and the complexity of the application as well as over twenty variables. putnam3 simplified staffing (life cycle curve) to a small and easily managed set of parameters that could be expressed in the form of nomograms.  this paper contributes to the software cost estimation by identifying those variables of the product which were found to be governing: the importance of distinguishing higher level language programming language systems (pls) from low level basic assembler language (bal), the importance of recognizing the major increase of effort if code is modified rather than new code created. the magnitude of these differences is quantified. finally in the analysis of the optional number of modules for a product, a balance is shown between the intramodule complexity and the intermodule complexity.  parametric data associated with program product development costs has been actively collected since mid-1976 by the program cost estimating department, now located at ibm's santa teresa laboratory. this data represents the actual person-month resources used to match program development requirements.  products that were analyzed are a collection of classic ibm mainframe products: languages (such as cobol, pl/i, apl), utilities (vsam, os utilities, sort, etc.), and data base products (ims, data dictionary, etc.). these are "system programs" rather than applications. the range and median sizes of the products are shown in table 1. twenty six of the thirty products contain modified modules.  robert e. boydston