waashk/acm huggingface dataset:
the myth: anyone can code the software of the requirements and design are...  the focus of this paper is the conjecture that the coding phase of a software system is difficult even in those instances where the functional requirements are well defined, the functional design is finalized, and the implementation issues are well understood.  to study this conjecture, we examined an actual implementation of a stack to discover what decisions the programmer encounters when attempting to transform the functional design into operational software code. we examine decisions affecting the specification of the stack package as well as those affecting the implementation of the subprograms in the body of this package.  j. a. perkins
when objects collide experiences with reusing multiple class hierarchies  well-designed reusable class libraries are often incompatible due to architectural mismatches such as error-handling and composition conventions. we identify five pragmatic dimensions along which combinations of subsystems must match, and present detailed examples of conflicts resulting from mismatches. examples are drawn from our experiences of integrating five subsystem-level class hierarchies into an object-oriented hypertext platform. we submit that effective reuse will require that these pragmatic decisions be explicitly identified in descriptions of reusable software. such descriptions will enable developers to identify and combine subsystems whose architectures are compatible.  lucy m. berlin
interface control and incremental development in the pic environment  the pic environment is designed to provide support for interface control that facilitates incremental development of a software system. interface control, the description and analysis of relationships among system components, is important from the earliest stages of the software development process right through to the implementation and maintenance stages. incremental development, wherein a software system is produced through a sequence of relatively small steps and progress may be rigorously and thoroughly assessed after each step, must be accommodated by any realistic model of the software development process. this paper focuses on the analysis component of the pic environment and demonstrates how it contributes to precise interface control capabilities while supporting an incremental software development process.  alexander l. wolf lori a. clarke jack c. wileden
an automated oracle for verifying gui objects recently, software testers have relied more on automated testing to test software. automated testing method consists of the three modules: test case design, execution, and verification. yet, to accomplish these three phases, we are always in a dilemma due to a lack of a verification function. nearly all the commercial automated testing tools cannot efficiently compare graphic objects though gui (graphic user interface) software is now more crucial than text based user interface. this research develops a technique that aids automatic behavior verification for a particularly difficult problem: determining the correction of screen output. methodology to capture and compare screen output is presented and a case study using microsoft® powerpoint® is described.
a study of exception handling and its dynamic optimization in java optimizing exception handling is critical for programs that frequently throw exceptions. we observed that there are many such exception-intensive programs iin various categories of java programs. there are two commonly used exception handling techniques, stack unwinding optimizes the normal path, while stack cutting optimizes the exception handling path. however, there has been no single exception handling technique to optimize both paths. takeshi ogasawara hideaki komatsu toshio nakatani
constructing usable documentation: a study of communicative practices and the early uses of mainframe computing in industry  this study suggests that computer documentation is a complex technical communication genre, encompassing all the texts that mediate between complex human activities and computer processes. drawing on a historical study, it demonstrates that the varied forms given to documentation have a long history, extending back at least to the early days of commercial mainframe computing. the data suggests that (1) early forms of computer documentation were borrowed from existing genres, and (2) official and unofficial documentation existed concurrently, despite efforts to consolidate these divergent texts. the study thus provides a glimpse into the early experimental nature of documentation as writers struggled to find a meaningful way to communicate information about their organization's developing computer technology.  mark zachry
evaluating software eng. methods and tools part 10: designing and running a quantitative case study in the last article we considered how to identify the context for a case study and how to define and validate a case study hypothesis. in this article, we continue my discussion of the eight steps involved in a quantitative case study by considering the remaining six steps: selecting the host projects; identifying the method of comparison; minimising the effect of confounding factors, planning the case study, monitoring the case study, analysing the results. barbara ann kitchenham lesley m. pickard
exception handling in apl  this paper examines apl exception handling facilities as they relate to applications programming. a brief background on exception handling is first presented. next, the qualities most desirable in an exception handler are discussed. these criteria are then used to examine and compare two different implementations of an exception handling facility, those of stsc, inc. and i. p. sharp associates (ipsa). finally, a set of apl- coded handlers is compared to the system-level implementations on the same basis.  dennis r. adler
understanding and using asynchronous message passing (preliminary version)  message passing provides a way for concurrently executing processes to communicate and synchronize. in this paper, we develop proof rules for asynchronous message-passing primitives (i.e. "send no- wait"). two benefits accrue from this. the obvious one is that partial correctness proofs can be written for concurrent programs that use such primitives. this allows programs to be understood as predicate transformers, instead of by contemplating all possible execution interleavings. the second benefit is that the proof rules and their derivation shed light on how interference arises when message- passing operations are used and on how this interference can be controlled. this provides insight into programming techniques to eliminate interference in programs that involve asynchronous activity. three safe uses of asynchronous message passing are described here: the transfer of values, the transfer of monotonic predicates, and the use of acknowledgments.  richard d. schlichting fred b. schneider
efficient dataflow analysis of logic programs  a framework for efficient dataflow analyses of logic programs is investigated. a number of problems arise in this context: aliasing effects can make analysis computationally expensive for sequential logic programming languages; synchronization issues can complicate the analysis of parallel logic programming languages; and finiteness restrictions to guarantee termination can limit the expressive power of such analyses. our main result is to give a simple characterization of a family of flow analyses where these issues can be ignored without compromising soundness. this results in algorithms that are simple to verify and implement, and efficient in execution. based on this approach, we describe an efficient algorithm for flow analysis of sequential logic programs, extend this approach to handle parallel executions, and finally describe how infinite chains in the analysis domain can be accommodated without compromising termination.  saumya k. debray
a programming environment for a timeshared system  in 1968 the stanford artificial intelligence laboratory began to construct a programming environment from a pdp-10, a pre-tops-10 dec1 timesharing system, and some innovative terminal hardware. by now this has developed into a programming environment for a kl-10 that integrates our editor with various other system functions, especially the lisp subsystem. we use the term 'sail' to refer to the stanford a. i. lab kl-10 computer running the waits timesharing system. [harvey 1982]  by 'programming environment' we mean the mechanisms that allow a user to type text at his program or subsystem, and which manage output text. 2 we are talking about mechanical management of the interaction between user and program, not about any intelligent mediation. a good programming environment should be flexible enough to suit individuals, yet without requiring the mechanics of interaction to be re-learned for each new program.  in this paper we describe our programming environment, what makes it unique, and why we think that it is not necessary to move to personal computers for a very usable programming environment.  richard p. gabriel martin e. frost
automat, an end-user approach in handling applications as multi-dimensional arrays  "automat" is an end user, general purpose tool developed initially in apl-sv currently running under vsapl and apl2 (ibm pc version currently under consideration).  the basic underlying concept is to tap the power of apl in handling multi- dimensional arrays, and make it available to the end user in a very natural and intuitive fashion.  the productivity gains generated by the system are extremely high, as a new application can be set up in terms of fraction of hours, with immediately usable results.  a lot of provisions have been made to handle instantaneously any changes in the structures, whether they are due to new business requirements or to initially overlooked facts.  the system has been and still is successfully used for data consolidation / analysis, planning models and application prototypes. the use of apl as internal language enables the system to communicate very easily with other applications (e.g. graphics).  jean marie monnier
a fully reusable class of objects for synchronization and communication in ada 95 this paper presents a very general class which can be reused to specify and implement any type exporting synchronization or communication properties. the new ada 95 features modelling inheritance, polymorphism and hierarchies of library units are used extensively in describing the architecture of the class and other new features (access to subprograms, protected types, …) are used for the specification and implementation of the components of the class.section 2 presents the general architecture of our class. sections 3, 4, 5 respectively give examples of specification, use and implementation of its components. section 6 concludes on recalling the full role of formal techniques in our approach (they appear in the present paper only to show that the semantics of our class is defined at a more abstract level than its implementation) and discussing a few interesting points about the way ada 95 is used here. patrick de bondeli
using apl expressions in database operations the collateral analysis system (cas) is an analytic database written in _dyalog apl_ which combines the flexibility of a database with the power of a sophisticated analysis package. much of the power and flexibility of cas comes from the ability of users to create their own selection statements, calculations, and summary expressions.an expression is a combination of _constants, fields_ and _user functions_ which can form a selection statement, new field calculation, or frequency report specification.users can generate tailor-made reports without programming. they simply enter expressions and format data and save the information with the database. then, with the touch of a button, they can generate reports quickly and easily. cas expressions are merely apl expressions in disguise. paul s. mansour stephen m. mansour
formal modeling and analysis of the hla component integration standard an increasingly important trend in the engineering of complex systems is the design of component integration standards. such standards define rules of interaction and shared communication infrastructure that permit composition of systems out of independently-developed parts. a problem with these standards is that it is often difficult to understand exactly what they require and provide, and to analyze them in order to understand their deeper properties. in this paper we use our experience in modeling the high level architecture (hla) for distributed simulation to show how one can capture the structured protocol inherent in an integration standard as a formal architectural model that can be analyzed to detect anomalies, race conditions, and deadlocks. robert j. allen david garlan james ivers
semantic analysis of virtual classes and tested classes  virtual classes and nested classes are distinguishing features of beta. nested classes originated from simula, but until recently they have not been part of main stream object- oriented languages. c++ has a restricted form of nested classes and they were included in java 1.1. virtual classes is the beta mechanism for expressing generic classes and virtual classes is an alternative to parameterized classes. there has recently been an increasing interest in virtual classes and a number of proposals for adding virtual classes to other languages, extending virtual classes, and unifying virtual classes and parameterized classes have been made. although virtual classes and nested classes have been used in beta for more than a decade, their implementation has not been published. the purpose of this paper is to contribute to the understanding of virtual classes and nested classes by presenting the central elements of the semantic analysis used in the mjølner beta compiler.  ole lehrmann madsen
parallel compilation of ada units  parallel compilation---compiling independent ada units or files in parallel--- offers a potentially enormous savings in the total compilation time of a program or library. the speedup realized depends primarily on the inter-unit dependency structure and the number of processors available.  we have developed a tool, adaexpress , which exploits the opportunities for parallelizing compilations that are inherent in ada libraries. adaexpress is currently targeted to a sequent symmetry multiprocessor environment. the compilation engine is a sequent ada compiler, a software leverage product that is derived from the verdix ada development system (vads®).  adaexpress automatically determines ada dependencies from sources. it then applies scheduling heuristics to the dependency structure to obtain a schedule with good, though suboptimal, overall compilation time. adaexpress implements this schedule as streams of parallel compilation processes.  we present the details of adaexpress's graph- based scheduling algorithm. we also give an example using adaexpress on an actual program library, and we show the speedup achieved with four processors.  b. cockerham
lazy and incremental program generation  current program generators usually operate in a greedy manner in the sense that a program must be generated in its entirety before it can be used. if generation time is scarce, or if the input to the generator is subject to modification, it may be better to be more cautious and to generate only those parts of the program that are indispensable for processing the particular data at hand. we call this lazy program generation. another, closely related strategy is incremental program generation. when its input is modified, an incremental generator will try to make a corresponding modification in its output rather than generate a completely new program. it may be advantageous to use a combination of both strategies in program generators that have to operate in a highly dynamic and/or interactive environment.  j. heering p. klint j. rekers
overcoming communication obstacles in user-analyst interaction for functional requirements elicitation the importance of requirement engineering in the software development process has been widely recognised by the scientific community. one of the major error sources that arise in this phase is represented by ineffectual communication between users and analysts.valusek and fryback in [32] identify three classes of communication obstacles to a successful elicitation of requirements. purpose of this paper is to discuss these obstacles and to identify the structure of a case tool that may allow to overcome them. s. valenti m. panti a. cucchiarelli
from reuse library experiences to application generation architectures  reuse through application generators has been successful in the area of programming language systems. we analyzed three language system projects that realized transition from the initial ad hoc programs, through libraries of reusable modules to application generator solutions. we tried to understand the underlying thinking process and technical factors that made such a transition possible. based on this study, we generalized reuse experiences gained in the language system domain and formulated a reuse implementation framework. our framework is to facilitate transition from component-based reuse to application generators in other domains. ultimately, we hope our framework will offer reuse implementation guidelines for companies to realize such a transition. initial findings are described in this paper.  stan jarzabek
algorithm 803: a simpler macro processor  macro processors have been in the computing tool chest since the late 1950's. their use, though perhaps not what it was in the heyday of assembly language programming, is still widespread. in the past, producing a full-featured macro processor has required significant effort, similar to that required to implement the front- end to a compiler augmented by appropriate text substitution capabilities. the tool described here adopts a different approach. the text containing macro definitions and substitutions is, in a sense, "compiled" to produce a program, and this program must then be executed to produce the final output.  william a. ward
a hierarchical description of the hermix distributed operating system  distributed operating systems are often structured in a server oriented way, where some system tasks are performed by server processes. for modularity reasons, hermix is build of a minimal kernel and many small servers; however to get a reasonable performance we use tools to merge servers together or to integrate them in our kernel.  in this paper we analyze the most basic services needed in server oriented systems. we give a description of these basic services and place them in a hierarchical structure. servers usually handle services from different layers and can therefore not be ordered hierarchically. our hierarchical description gives a better insight in the relationships between inter-process communication, memory management based on swapping and both low level and high level process management.  yolande berbers pierre verbaeten
lispview: leverage through integration  although lisp was the host for many of the first graphical user interface (gui) packages, popular activity in this area has shifted to more primitive but widely used languages such as c and c++. one explanation for this shift is that while lisp's strength in rapid prototyping and development led to the initial progress, it also tended to inspire an imperialist attitude: applications were often crafted exclusively in lisp, even when part of the application could make use of an existing conventional language library. we believe the ideal way to construct a commonlisp gui package today is to integrate proven c libraries with an object-oriented lisp framework.  hans muller
replicate each, anyone?  in both the ipsa and apl2/nars extensions of apl, the slash symbol always represents an operator. some new users of apl2, having been taught in the past that slash is an ambiguous symbol which is a dyadic function when it immediately follows data, find that the result when slash occurs between data and another operator is incompatible with that interpretation. the situation did not arise in apl1 because derived functions could not be operands. the classification of slash as an operator can be traced to the description given in the book. a programming language, from which apl ultimately derives. it was done so that the closely related mask operation could be specified with the same symbol. in this paper the syntactic differences between dyadic functions and aonadic operators with data operands are explicated using the apl2 concept of syntactic binding. two straightforward language extensions are considered based on the notions of a depth property, which apl2 shares with stsc's nars, and pairwise evaluation, which derives from syntactic binding. together they allow either dyadic functions or monadic operators with data operands to be executed in three structural contexts, which, in the cases of replicate and expand, can be loosely described as the same mask for each of several arrays, a separate mask for each array, and the same array for each of several masks.  j. philip benkard
a new graphical user interface proposal for apl  in the past apl had two significant advantages over many other problem-solving computational tools. the first of these was that the language elements of apl have a consistency and breadth that remains unchallenged, at least for the tasks for which they were designed. the other historic advantage of apl, that it provided an interactive problem-solving environment, has long since been eroded. indeed, we have seen a transformation of some programming languages into programming environments.  the purpose of this paper is to explore some possible ways in which the face that apl presents to those who program with it could usefully be enhanced.  dick bowman
reducing indirect function call overhead in c++ programs  modern computer architectures increasingly depend on mechanisms that estimate future control flow decisions to increase performance. mechanisms such as speculative execution and prefetching are becoming standard architectural mechanisms that rely on control flow prediction to prefetch and speculatively execute future instructions. at the same time, computer programmers are increasingly turning to object-oriented languages to increase their productivity. these languages commonly use run time dispatching to implement object polymorphism. dispatching is usually implemented using an indirect function call, which presents challenges to existing control flow prediction techniques.  we have measured the occurrence of indirect function calls in a collection of c++ programs. we show that, although it is more important to predict branches accurately, indirect call prediction is also an important factor in some programs and will grow in importance with the growth of object-oriented programming. we examine the improvement offered by compile-time optimizations and static and dynamic prediction techniques, and demonstrate how compilers can use existing branch prediction mechanisms to improve performance in c++ programs. using these methods with the programs we examined, the number of instructions between mispredicted breaks in control can be doubled on existing computers.  brad calder dirk grunwald
precise and efficient integration of interprocedural alias information into data-flow analysis  data-flow analysis is a basis for program optimization and parallelizing transformations. the mechanism of passing reference parameters at call sites generates interprocedural aliases which complicate this analysis. solutions have been developed for efficiently computing interprocedural aliases. however, factoring the computed aliases into data- flow information has been mostly overlooked, although improper factoring results in imprecise (conservative) data-flow information. in this document, we describe a mechanism which, in factoring in interprocedural aliases, computes data-flow information more precisely and with less time and space overhead than previous approaches.  michael burke jong-deok choi