waashk/acm huggingface dataset:
fifty years of progress in software engineering in this paper, i describe a new outlook on the history of software engineering. i portray large-scale structures within software engineering to give a better understanding of the flow of history. i use these large-scale structures to reveal the steady, ongoing evolution of concepts, and show how they relate to the myriad whorls and eddies of change. i also have four smaller, more specific purposes in writing this paper.first, i want to point out that old ideas do not die. in the mythical man-month after 20 years, brooks claims "the waterfall model is wrong." but if the waterfall model were wrong, we would stop arguing over it. though the waterfall model may not describe the whole truth, it describes an interesting structure that occurs in many well-defined projects and it will continue to describe this truth for a long time to come. i expect the waterfall model will live on for the next one hundred years and more.second, i want to show that the chaos model, chaos life cycle, complexity gap, and chaos strategy are part of the natural evolution of software engineering. the chaos model and strategy supersede, but do not contradict, the waterfall and spiral models, and the stepwise refinement strategy. they are more up to date because they express contemporary issues more effectively, and fit our contemporary situations better. the chaos model, life cycle, and strategy are equally as important, but not better than, other concepts.third, i compare the chaos model, life cycle, and strategy to other models, life cycles, and strategies. this paper can be considered a comparison of the ideas presented in my papers about chaos with other ideas in the field. i avoided comparisons in my other papers because i wanted to define those ideas in their own terms and the comparisons did not further the new ideas.fourth, i make a few predictions about the next ten years of software engineering. the large-scale structures described in this history provide a stronger base for understanding how software engineering will evolve in the future.this paper is laid out as follows. in the first section, i use the flow of water as a metaphor to describe the flow of progress in software engineering. i use the water metaphor to show some of the structures within software engineering. the current work builds on top of the historical work, and future work will build on top of current work. in the remaining sections, i describe the waves, streams, and tides that portray the evolution of concepts and technologies in software engineering. l. b. s. raccoon
improved lineariser methods for queueing networks with queue dependent centres  the lineariser is an mva-based technique developed for the approximate solution of large multiclass product form queueing networks. the lineariser is capable of computing accurate solutions for networks of fixed rate centres. however, problems arise when the lineariser is applied to networks containing centres with queue dependent service rates. thus networks exist which seem well suited (a large number of lightly loaded centres, large numbers of customers in each closed chain) for lineariser solution but whose queue dependent centres cannot be solved accurately by the lineariser method. examples have also been found where the lineariser computes accurate values for the queue lengths, waiting times and throughputs though the values computed for the queue length distributions are totally in error.  this paper presents an improved lineariser which computes accurate approximate solutions for multiclass networks containing an arbitrary number of queue dependent centres. the improved lineariser is based on mva results and is therefore simple to implement and numerically well behaved. the improved lineariser has storage and computation requirements of order (mn) locations and (mnj2) arithmetic operations where m is the number of centres, n the total number of customers and j the number of closed chains.  results from 130 randomly generated test networks are used to compare the accuracy of the standard and improved linearisers. the improved lineariser is consistently more accurate (tolerance errors on all performance measures less than 2 per cent) than the standard lineariser and its accuracy is insensitive to the size of the network model. in addition, the improved lineariser computes accurate solutions for networks which cause the standard lineariser to fail.  a. krzesinski j. greyling
transparent replication for fault tolerance in distributed ada 95 in this paper we present the foundations of rapids ("replicated ada partitions in distributed systems"), an implementation of the pcs supporting the transparent replication of partitions in distributed ada 95 using semi-active replication. the inherently non-deterministic executions of multi-tasked partitions are modeled as piecewise deterministic histories. i discuss the validity and correctness of this model of computation and show how it can be used for efficient semi-active replication. the rapids prototype ensures that replicas of a partition all go through the same history and are hence consistent. thomas wolf
computational reflection in class based object-oriented languages  this paper describes various models of computational reflection in class based object oriented language. two different approaches are covered: the meta- object approach which supposes that every object can have a meta- object describing and monitoring its behavior, and the message reification approach which describes a message as an object. the meta-object approach is discussed more fully showing that it is important to differentiate between structural reflection and computational reflection. we will see that, whereas classes and metaclasses are very important for the former, they cannot cope adequately with the later. therefore we introduce a model of computational reflection where meta-objects are instances of a class meta-object or of one of its subclasses.  j. ferber
continuous execution: the visiprog environment  to date, program development environments have been static rather than dynamic. even emerging interactive, integrated program development environments, like the cornell program synthesizer, view program editing and execution as essentially independent activities. we envision an even more dynamic environment in which the functionality (input/output relationship) of a network of programs, an individual program, or a program segment can be viewed "continuously" with editing changes to either the program input or program body. this is the visicalc concept extended to program development environments (visiprog). in this paper, this "dynamic" approach to program development, testing and debugging is addressed, and considerations for the user interface are discussed. the latter includes a workstation with a flexible windowing system, three-dimensional views of programs, insertion of program control and observation points, and dynamic program slicing for "viewing" program execution. an existing prototype and current development activities are also discussed.  peter henderson mark weiser
software lending library  cornell university has a rather unique approach in microcomputer user support. in the spring of 1983, we ordered several software packages for our office ibm personal computers. at the time we also purchased all the microcomputers for university departments. because of this situation, we were in the public eye of campus microcomputer users. people would inquire about our software as they saw it in our office. how did we like it? could they try it? remember, software is usually purchased for a specific machine. how did we provide support to our campus users and remain legal?  since we were such a public area we thought that something like a lending library might be a feasible option. we drafted policies on how we would check out software packages. a deposit, either a check or a departmental account number, would be required. people could check out a package for a week at a time, and they would have to sign a form stating that they had no intention of copying either the software or the documentation. we then drafted a letter to the dozen or so companies whose software we had and asked their permission to let users try the software. enclosed with each letter was a copy of the form users would sign indicating the restrictions and limitations of use. much to our delight, most companies responded very favorably to our request.  after this initial success, i decided to carry the library one step further. we supported apple, ibm, and dec microcomputers for the campus and subscribed to a number of computer magazines. i selected about 100 packages that had received good reviews from campus users and/or magazines. these companies were contacted and asked if they would participate in our library by supplying us with a package. if this was not possible, did they have a demonstration package, or could they give us some kind of a discount? the result is a three- page list of software housed in the lending library. the list is updated monthly (some packages arrive for a 30-60 day trial), because of new additions. most companies are more than happy to participate and approve of our attempts to keep materials secure.  many of the software companies were unsure how to respond to this novel idea. since the inception of the lending library, several universities and the cornell medical college in new york city have contacted us for guidance and advice on how "to get started." it is certainly worth the time and effort to begin such a library and support the users in this way.  karen w. allen
array oriented exception handling: a proposal for dealing with "invalid" data  apl still deals poorly with some aspects of real world problems. for instance, frequently to mark entries in an otherwise numeric database as "not applicable" or "not entered," one picks arbitrarily one or more numbers to represent the attributes. but this and other approaches suffer difficulties ranging from ambiguity to inefficiencies in both programming and execution. further, apl errors which might logically be associated with individual elements of data arrays are not reported by existing apl systems in any detail. this paper proposes an enhancement to apl which would overcome both these difficulties, discussing considerations of both use and implementation.  jim lucas
effective synchronization removal for java  we present a new technique for removing unnecessary synchronization operations from statically compiled java programs. our approach improves upon current efforts based on escape analysis, as it can eliminate synchronization operations even on objects that escape their allocating threads. it makes use of a compact, equivalence-class- based representation that eliminates the need for fixed point operations during the analysis.  we describe and evaluate the performance of an implementation in themarmot native java compiler. for the benchmark programs examined, the optimization removes 100% of the dynamic synchronization operations in single-threaded programs, and 0-99% in multi- threaded programs, at a low cost in additional compilation time and code growth.  erik ruf
components and generative programming (invited paper)  this paper is about a paradigm shift from the current practice of manually searching for and adapting components and their manual assembly to generative programming, which is the automatic selection and assembly of components on demand. first, we argue that the current oo technology does not support reuse and configurability in an effective way. then we show how a system family approach can aid in defining reusable components. finally, we describe how automate the assembly of components based on configuration knowledge. we compare this paradigm shift to the introduction of interchangeable parts and automated assembly lines in the automobile industry.  we also illustrate the steps necessary to develop a product line using a simple example of a car product line. we present the feature model of the product line, develop a layered architecture for it, and automate the assembly of the components using a generator. we also discuss some design issues, applicability of the approach, and future development.  krzysztof czarnecki ulrich w. eisenecker
workshop on multi-dimensional separation of concerns in software engineering (workshop session)  separation of concerns has been central to software engineering for decades, yet its many advantages are still not fully realized. a key reason is that traditional modularization mechanisms do not allow simultaneous decomposition according to multiple kinds of (overlapping and interacting) concerns. this workshop was intended to bring together researchers working on more advanced modularization mechanisms, and practitioners who have experienced the need for them, as a step towards a common understanding of the issues, problems and research challenges.  peri tarr william harrison harold ossher anthony finkelstein bashar nuseibeh dewayne perry
extracting library-based object-oriented applications  in an increasingly popular model of software distribution, software is developed in one computing environment and deployed in other environments by transfer over the internet. extraction tools perform a static whole-program analysis to determine unused functionality in applications in order to reduce the time required to download applications. we have identified a number of scenarios where extraction tools require information beyond what can be inferred through static analysis: software distributions other than complete applications, the use of reflection, and situations where an application uses separately developed class libraries. this paper explores these issues, and introduces a modular specification language for expressing the information required for extraction. we implemented this language in the context of _jax_, an industrial-strength application extractor for java, and present a small case study in which different extraction scenarios are applied to a commercially available library-based application.  peter f. sweeney frank tip
fortran 95 iso/iec 1539 is a multipart international standard; the parts are published separately. this publication, 1539-1, which is the first part, specifies the form and establishes the interpretation of programs expressed in the fortran language. the purpose of this part is to promote portability, reliability, maintainability, and efficient execution of fortran programs for use on a variety of computing systems. the second part, 1539-2, defines additional facilities for the manipulation of character strings of variable length. a processor conforming to 1539-1 need not conform to 1539-2; however, conformance to 1539-2 assumes conformance to this part. throughout this publication, the term "this standard" refers to 1539-1. corporate ansi accredited technical subcommittee x3j3
c compiler design for an industrial network processor  one important problem in code generation for embedded processors is the design of efficient compilers for asips with application specific architectures. this paper outlines the design of a c compiler for an industrial asip for telecom applications. the target asip is a network processor with special instructions for bit-level access to data registers, which is required for packet-oriented communication protocol processing. from a practical viewpoint, we describe the main challenges in exploiting these application specific features in a c compiler, and we show how a compiler backend has been designed that accomodates these features by means of compiler intrinsics and a dedicated register allocator. the compiler is fully operational, and first experimental results indicate that c-level programming of the asip leads to good code quality without the need for time-consuming assembly programming.  jens wagner rainer leupers
incorporating usability into requirements engineering tools  the development of a computer system requires the definition of a precise set of properties or constraints that the system must satisfy with maximum economy and efficiency. this definition process requires a significant amount of communication between the requestor and the developer of the system. in recent years, several methodologies and tools have been proposed to improve this communication process. this paper establishes a framework for examining the methodologies and techniques, charting the progress made, and identifying opportunities to improve the communication capabilities of a requirements engineering tool.  gregory l. smith sharon a. stephens leonard l. tripp wayne l. warren
brouhaha- a portable smalltalk interpreter  brouhaha is a portable implementation of the smalltalk-80 virtual machine interpreter. it is a more efficient redesign of the standard smalltalk specification, and is tailored to suit conventional 32 bit microprocessors. this paper presents the major design changes and optimization techniques used in the brouhaha interpreter. the interpreter runs at 30% of the speed of the dorado on a sun 3/160 workstation. the implementation is portable because it is written in c.  eliot miranda
sufficient test sets for path analysis testing strategies  many testing methods require the selection of a set of paths over which testing is to be conducted. this paper presents an analysis of the effectiveness of individual paths for testing predicates in linearly domained programs. a measure is derived for the marginal advantage of testing another path after several paths have already been tested. this measure is used to show that any predicate in such programs may be sufficiently tested using at most m+n+1 paths, where m is the number of input values and n is the number of program variables.  steven j. zeil lee j. white
programmer performance and the effects of the workplace  wide variation in programmer performance has been frequently reported in the literature [1, 2, 3]. in the absence of other explanation, most managers have come to accept that the variation is due to individual characteristics. the presumption that there are order-of-magnitude differences in individual performance makes accurate cost projection seem nearly impossible.  in an extensive study, 166 programmers from 35 different organizations, participated in a one-day implementation benchmarking exercise. while there were wide variations across the sample, we found evidence that characteristics of the workplace and of the organization seemed to explain a significant part of the difference.  tom demarco tim lister
interprocedural modification side effect analysis with pointer aliasing  we present a new interprocedural modification side effects algorithm for c programs, that can discern side effects through general-purpose pointer usage. ours is the first complete design and implementation of such an algorithm. preliminary performance findings support the practicality of the technique, which is based on our previous approximation algorithm for pointer aliases [lr92]. each indirect store through a pointer variable is found, on average, to correspond to a store into 1.2 locations. this indicates that our program- point-specific pointer aliasing information is quite precise when used to determine the effects of these stores.  william landi barbara g. ryder sean zhang
an ada-like separate compilation style in c the ada programming language's modularity allows for stepwise refinement in software engineering. effective separate compilation is crucial in most large systems, including those written in c. an approach to implementing effective modularity in c, modeled after ada, is explored. the concept of language-independent modularity, and the possibility of implementing it in a given "entry level" language is introduced. an example, a simple sentence parser, is developed in c using this concept. the technique, called a/sc2, may easily be extended to other programming systems and languages. modeling modularity is a useful design tool. alexy v. khrabrov
surveying current research in object-oriented design  the state of object-oriented is evolving rapidly. this survey describes what are currently thought to be the key ideas. although it is necessarily incomplete, it contains both academic and industrial efforts and describes work in both the united states and europe. it ignores well-known ideas, like that of coad and meyer [34], in favor of less widely known projects.  research in object-oriented design can be divided many ways. some research is focused on describing a design process. some is focused on finding rules for good designs. a third approach is to build tools to support design. most of the research described in this article does all three.  we first present work from alan snyder at hewlett-packard on developing a common framework for object-oriented terminology. the goal of this effort is to develop and communicate a corporate-wide common language for specifying and communicating about objects.  we next look into the research activity at hewlett-packard, led by dennis de champeaux. de champeaux is developing a model for object-based analysis. his current research focuses on the use of a trigger-based model for inter-object communications and development of a top-down approach to analysis using ensembles.  we then survey two research activities that prescribe the design process. rebecca wirfs-brock from tektronix has been developing an object-oriented design method that focuses on object responsibilities and collaborations. the method includes graphical tools for improving encapsulation and understanding patterns of object communication. trygve reenskaug at the center for industriforskning in oslo, norway has been developing an object-oriented design method that focuses on roles, synthesis, and structuring. the method, called object-oriented role analysis, syntheses and structuring, is based on first modeling small sub-problems, and then combining small models into larger ones in a controlled manner using both inheritance (synthesis) and run-time binding (structuring).  we then present investigations by ralph johnson at the university of illinois at urbana-champaign into object-oriented frameworks and the reuse of large- scale designs. a framework is a high-level design or application architecture and consists of a suite of classes that are specifically designed to be refined and used as a group. past work has focused on describing frameworks and how they are developed. current work includes the design of tools to make it easier to design frameworks.  finally, we present some results from the research group in object-oriented software engineering at northeastern university, led by karl lieberherr. they have been working on object-oriented computer assisted software engineering (case) technology, called the demeterm system, which generates language- specific class definitions from language- independent class dictionaries. the demeter system include tools for checking design rules and for implementing a design.  rebecca j. wirfs-brock ralph e. johnson
selective and lightweight closure conversion  we consider the problem of selective and lightweight closure conversion, in which multiple procedure- calling protocols may coexist in the same code. flow analysis is used to match the protocol expected by each procedure and the protocol used at each of its possible call sites. we formulate the flow analysis as the solution of a set of constraints, and show that any solution to the constraints justifies the resulting transformation. some of the techniques used are suggested by those of abstract interpretation, but others arise out of alternative approaches.  mitchell wand paul steckler