waashk/acm huggingface dataset:
documenting software systems with views  software professionals rely on internal documentation as an aid in understanding programs. unfortunately, the documentation for most programs is usually out-of-date and cannot be trusted. without it, the only reliable and objective information is the source code itself. personnel must spend an inordinate amount of time exploring the system by looking at low-level source code to gain an understanding of its functionality. one way of producing accurate documentation for an existing software system is through reverse engineering. this paper outlines a reverse engineering methodology for building subsystem structures out of software building blocks, and describes how documenting a software system with views created by this process can produce numerous benefits. it addresses primarily the needs of the software engineer and technical manager as document users.  scott r. tilley hausi a. muller mehmet a. orgun
the portable common runtime approach to interoperability  operating system abstractions do not always reach high enough for direct use by a language or applications designer. the gap is filled by language-specific runtime environments, which become more complex for richer languages (commonlisp needs more than c+ +, which needs more than c). but language- specific environments inhibit integrated multi-lingual programming, and also make porting hard (for instance, because of operating system dependencies). to help solve these problems, we have built the portable common runtime (pcr), a language-independent and operating-system-independent base for modern languages. pcr offers four interrelated facilities: storage management (including universal garbage collection), symbol binding (including static and dynamic linking and loading), threads (lightweight processes), and low-level i/o (including network sockets). pcr is "common" because these facilities simultaneously support programs in several languages. pcr supports c. cedar, scheme, and commonlisp intercalling and runs pre-existing c and commonlisp (kyoto) binaries. pcr is "portable" because it uses only a small set of operating system features. the pcr source code is available for use by other researchers and developers.  m. weiser a. demers c. hauser
choices in server-side programming: a comparative programming exercise one of the fastest growing and changing fields for software developers is in writing applications that are used across the "world wide web", which is in turn a client-server system that runs on the internet. servers, known by name, can be accessed over the internet, and a protocol, known as http (hypertext transfer protocol) is used to send requests to servers for text, images (still and moving), audio, and other information. a very large amount of business will be conducted this way, now and in the future, having grown from almost nothing only 5 years ago. application development on the web is largely a matter of writing programs that are executed by the server, and we're going to focus our attention on two programming and operating environments that can be used to deliver server-side software.we would like to show how apl can be used to develop programs that run on the server, and we will contrast it with another means of developing and delivering server-side programs. it is not our goal to deliver any judgment about whether or not one system is "better" than the other (we believe that any such statement would be simplistic to the point of being misleading); we intend only to share the results of our experience, help the reader understand what technologies that are available, and assist in making an informed choice if participation in a project of this nature is part of what the reader does. robert g. brown willi hahn
how to make ad-hoc polymorphism less ad hoc  this paper presents type classes, a new approach to ad-hoc polymorphism. type classes permit overloading of arithmetic operators such as multiplication, and generalise the "eqtype variables" of standard ml. type classes extend the hindley/milner polymorphic type system, and provide a new approach to issues that arise in object-oriented programming, bounded type quantification, and abstract data types. this paper provides an informal introduction to type classes, and defines them formally by means of type inference rules.  p. wadler s. blott
transparent fault tolerance for distributed ada applications  the advent of open architectures and initiatives in massively parallel supercomputing, combined with the maturation of distributed processing methods and algorithms, has enabled the implementation of responsive software-based fault tolerance. expanding capabilities of distributed ada runtime environments further stimulate the incorporation of hardware fault tolerance into critical, realtime embedded systems. through the integration of proven ada program component distribution and virtually synchronous communication protocols, we have established a benchmark fault tolerant system, which layers transparently between an ada application and the runtime environment. such transparence allows rapid reconfiguration of distribution and fault tolerance characteristics without change to the source code, thus enhancing portability, scalability, and reuse.  the ada fault tolerance project has implemented software technologies which penetrate the envelope of an ada program to detect, diagnose, and recover from hardware faults. these realtime facilities interact with the rational distributed application development and runtime environment systems to service replicated ada software tasks (i.e., threads of control). the deployed system proves that all replicated threads, including those of independently distributed components, can achieve timely consensus during periodic fault detection cycles through transparently embedded voting protocols. our implementation uses a hybrid redundancy computation strategy and relies on a communication layer which provides virtual synchrony via a causal multicast protocol.  mark a. breland steven a. rogers guillaume p. brat kenneth l. nelson
migration of processes, files, and virtual devices in the mdx operating system load management in distributed systems is usually focused on balancing process execution and communication load. stress on storage media and i/o-devices is considered only indirectly or disregarded. for i/o-intensive processes this imposes severe restrictions on balancing algorithms: processes have to be placed relative to fixed allocated resources. therefore, beyond process migration, there is a need for a migration of all operating system objects, like files, pipes, timers, virtual terminals, and print jobs. in addition to new options for balancing cpu loads, this also makes it possible to balance the loads associated with these objects like storage capacity or i/o-bandwidth.this paper presents a concept for a general migration of nearly all operating system objects of a unix environment. the migrations of these objects work all in the same unix compliant and transparent manner. objects can be moved throughout a distributed system independently of each other and at any time, according to a user defined policy. the migration mechanism is implemented as part of the mdx operating system; we present performance measurements. we believe that most of the mechanism can also apply to other message-passing based distributed operating systems. harald schrimpf
elint in lamina: application of a concurrent object language  the design and performance of an "expert system" signal interpretation application written in a concurrent object-based programming language, lamina, is described together with a synopsis of the programming model that forms the foundation of the language. the effects of load balancing and the limits imposed by task granularity and message transmission costs are studied and their consequences to application performance are measured over the range of one to 250 processors as simulated in simple/care, an extensively instrumented simulation system and computer array model.  b. a. delagi n. p. saraiya
alternatives to construct-based programming misconceptions  in this paper, we investigate whether or not most novice programming bugs arise because students have misconceptions about the semantics of particular language constructs. three high frequency bugs are examined in detail --- one that clearly arises from a construct-based misconception, one that does not, and one that is less cut and dry. based on our empirical study of 101 bug types from three programming problems, we will argue that most bugs are not due to misconceptions about the semantics of language constructs.  j. c. spohrer e. soloway
the cost of selective recompilation and environment processing  when a single software module in a large system is modified, a potentially large number of other modules may have to be recompiled. by reducing both the number of compilations and the amount of input processed by each compilation run, the turnaround time after changes can be reduced significantly.  potential time savings are measured in a medium-sized, industrial software project over a three-year period. the results indicate that a large number of compilations caused by traditional compilation unit dependencies may be redundant. on the available data, a mechanism that compares compiler output saves about 25 percent, smart recompilation saves 50 percent, and smartest recompilation may save up to 80 percent of compilation work.  furthermore, all compilation methods other than smartest recompilation process large amounts of unused environment data. in the project analyzed, the average environment symbols are actually used. reading only the actually used symbols would reduce total compiler input by about 50 percent.  combining smart recompilation with a reduction in environment processing might double to triple perceived compilation speed and double linker speed, without sacrificing static type safety.  rolf adams walter tichy annette weinert
a practical method for syntactic error diagnosis and recovery  our goal is to develop a practical syntactic error recovery method applicable within the general framework of viable prefix parsing. our method represents an attempt to accurately diagnose and report all syntax errors without reporting errors that are not actually present. successful recovery depends upon accurate diagnosis of errors together with sensible "correction" or alteration of the text to put the parse back on track. the issuing of accurate and helpful diagnostics is achieved by indicating the nature of the recovery made for each error encountered. the error recovery is prior to and independent of any semantic analysis of the program. however, the method does not exclude the invocation of semantic actions while parsing or preclude the use of semantic information for error recovery.  the method assumes a framework in which an lr or ll parser, driven by the tables produced by a parser generator, maintains an input symbol buffer, state or prediction stack, and parse stack. the input symbol buffer contains part or all of the sequence of remaining input tokens, including the current token. the lr state stack is analogous to the ll prediction stack; except when restricting our attention to the ll case, prediction stack shall serve as a generic term indicating the lr state or ll prediction stack. the parse stack contains the symbols of the right hand sides that have not yet been reduced.  michael burke gerald a. fisher
architecture of the advanced development environment (abstract only)  reusing large software components has the potential to increase development productivity and improve software quality. the advanced development environment consists of five components: the resource of reusable software, the release management system, the automated system design, the catalog, and the workstation. the catalog maintains descriptive information about reusable components and the facilities in the workstation. a reusable component can be a subsystem, a feature, a transaction or a program. subsystems consist of features; features consist of transactions and transactions consist of programs. the workstation provides graphics and inquiries capabilities for the environment. the reusable component selector, the screen formatter and the database modeler are the major utilities in the workstation.  james ambroise yat kat chan
learning the interaction between pointers and scope in c++  traditionally, pointers, and their interaction with scope in c++ have been a source of frustration and confusion for students in our computer science ii course. since problem-solving is known to improve learning [6], we set out to develop software that would help our students better understand these concepts by repeatedly solving problems based on them.  in this paper, we will first describe the design and features of this software. we conducted tests in two sections of our computer science ii course this fall to evaluate the effectiveness of using this software. the results have been very encouraging: the class average in both the sections increased by 100% from the pretest to the post-test. we will also present the design and results of these tests.  amruth n. kumar
balanced job bound analysis of queueing networks  applications of queueing network models to computer system performance prediction typically involve the computation of their equilibrium solution. when numerous alternative systems are to be examined and the numbers of devices and customers are large, however, the expense of computing the exact solutions may not be warranted by the accuracy required. in such situations, it is desirable to be able to obtain bounds on the system solution with very little computation. asymptotic bound analysis (aba) is one technique for obtaining such bounds. in this paper, we introduce another bounding technique, called balanced job bounds (bjb), which is based on the analysis of systems in which all devices are equally utilized. these bounds are tighter than aba bounds in many cases, but they are based on more restrictive assumptions (namely, those that lead to separable queueing network models).  j. zahorjan k. c. sevcik d. l. eager b. i. galler
elements of style: analyzing a software design feature with a counterexample detector we illustrate the application of nitpick, a specification checker, to the design of a style mechanism for a word processor. the design is cast, along with some expected properties, in a subset of z. nitpick checks a property by enumerating all possible cases within some finite bounds, displaying as a counterexample the first case for which the property fails to hold. unlike animation or execution tools, nitpick does not require state transitions to be expressed constructively, and unlike theorem provers, operates completely automatically without user intervention. using a variety of reduction mechanisms, it can cover an enormous number of cases in a reasonable time, so that subtle flaws can be rapidly detected. daniel jackson craig a. damon
design criteria for a pc-based common user interface to remote information systems (abstract only)  the problems associated with retrieval by casual users of information stored in remote is&amp;r; systems and the possible utilization of personal computers to solve these problems are discussed. a standardized system which will allow the user to access information stored in many distinct systems through a single common interface is described. the intent of this system is to spare the user the necessity of learning multiple command languages in order to access multiple systems and also retain the full retrieval capabilities of each system. several levels of interaction are provided to facilitate new user learning phase activity and allow the intermediate and advanced users to interact with the system with the minimum necessary prompting. the system is designed to maximize utilization of local processing and display capabilities and to provide built-in evaluation tools.  philip hall
modular interprocedural pointer analysis using access paths: design, implementation, and evaluation  in this paper we present a modular interprocedural pointer analysis algorithm based on access-paths for c programs. we argue that access paths can reduce the overhead of representing context-sensitive transfer functions and effectively distinguish non-recursive heap objects. and when the modular analysis paradigm is used together with other techniques to handle type casts and function pointers, we are able to handle significant programs like those in the speccint92 and speccint95 suites. we have implemented the algorithm and tested it on a pentium ii 450 pc running linux. the observed resource consumption and performance improvement are very encouraging.  ben-chung cheng wen-mei w. hwu
the ergo support system: an integrated set of tools for prototyping integrated environments  the ergo support system (ess) is an engineering framework for experimentation and prototyping to support the application of formal methods to program development, ranging from program analysis and derivation to proof-theoretic approaches. the ess is a growing suite of tools that are linked together by means of a set of abstract interfaces. the principal engineering challenge is the design of abstract interfaces that are semantically rich and yet flexible enough to permit experimentation with a wide variety of formally-based program and proof development paradigms and associated languages. as part of the design of ess, several abstract interface designs have been developed that provide for more effective component integration while preserving flexibility and the potential for scaling. a benefit of the open architecture approach of ess is the ability to mix formal and informal approaches in the same environment architecture. the ess has already been applied in a number of formal methods experiments.  peter lee frank pfenning gene rollins william scherlis
apl function variants and system labels  while apl extensions are adding power to the language by generalizing and adding operators, the necessity of defining additional attributes of functions is becoming increasingly visible and no longer ignorable. this paper describes the function variant problem, and proposes a solution by introducing the concept of system labels. three system labels are described: (@@@@)id for the identity function, (@@@@)inv for the inverse function, (@@@@)fl for the fill function.  david a. rabenhorst
transparent files in apl (a preliminary proposal)  file-related operations in apl could be classified according to whether manipulation of the file is restricted solely to apl or whether the file is to be accessible via another language. in the latter case communication is often dependent on the other language and should not affect apl language design, except for the provision of a general facility. guidelines for using shared variables and defined functions to this end are presented. files strictly intra-apl can and should be independent of such external communication, and a detailed proposal is presented whereby such internal files can be viewed and manipulated as if they were ordinary variables. the same conventions could also be extended to cover named objects in the workspace, thus giving enhanced access control within the workspace. concerns addressed include syntax and nomenclature for reference to controlled or extra-workspace named objects, space constraints, error classification and reporting, upward compatibility, and to some extent, implementation concerns.  jim lucas
regression test selection for java software regression testing is applied to modified software to provide confidence that the changed parts behave as intended and that the unchanged parts have not been adversely affected by the modifications. to reduce the cost of regression testing, test cases are selected from the test suite that was used to test the original version of the software---this process is called regression test selection. a _safe_ regression-test-selection algorithm selects every test case in the test suite that may reveal a fault in the modified software. safe regression-test- selection technique that, based on the use of a suitable representation, handles the features of the java language. unlike other safe regression test selection techniques, the presented technique also handles incomplete programs. the technique can thus be safely applied in the (very common) case of java software that uses external libraries of components; the analysis of the external code is note required for the technique to select test cases for such software. the paper also describes retest, a regression- test-selection algorithm can be effective in reducing the size of the test suite. mary jean harrold james a. jones tongyu li donglin liang ashish gujarathi
generalization of leaner object-oriented slicing the leaner object-oriented slicing technique in [2], albeit effective in providing further code reduction from an object-oriented slice, fails to handle an object-oriented slice with multiple inheritance nets. that is, an object-oriented slice in a tree form with multiple branches is beyond the ability of leaner object-oriented slicing. this paper proposes a new approach which extends the applicability of code reduction by leaner object-oriented slicing. a generalized leaner object- oriented slicing method can now be achieved which provides further code reduction for general object-oriented slices. rob law
a framework for encapsulating card-oriented, interactive, legacy applications over the last several years lockheed martin has invested ir&amp;d; funds to explore lowering the cost of ownership of command and control systems for dod software intensive systems. two key technologies that address this issue are developing software components that can be reused across a family of systems within the command and control domain and methods for reusing legacy system applications. this paper describes how these two approaches have been merged using object oriented technology to provide a reusable framework for encapsulating legacy applications.the object oriented technology (oot) that we consider key to lowering cost of ownership and to strategies for reuse of legacy code is described as design patterns [gamma] and frameworks[coplien]. design patterns exist at a level of abstraction that provides a high return on reuse investment because they model stable relationships that are not likely to change as a system evolves and which can be reused across systems [coplien]. it is not the intent of this paper to describe these terms. rather it is our purpose to illustrate the advantages of this level of oot. al butkus barbara l. mitchell
the syntax of apl, an old approach revisited  most efforts have been made in the past apl conferences to propose new approaches to the analysis of apl, and introduce new features in the language. however, most of these proposals take very little in account the amount of work that has been made around syntax analysis in the 'main stream' of computer science.  the proposed approach, as described in this paper, can therefore be considered as an old work. we first describe the fundamental syntactic devices of apl. those devices are then arranged as a standard bnf. we can exhibit some properties of the language described, and consequently select from the literature an appropriate technique to perform the syntax analysis of apl expressions. the proposed method uses a push-down automaton. although the language is shown to be not lr(k), an adaptation of this technique works well using backtracking.  the whole process has been modelled in apl. a first application transforms a grammar expressed as a bnf in a set of tables. a second application uses these tables to perform the syntax analysis of apl statements. these last programs have been rewritten in c, integrated in an apl system, and used to test different dialects of apl, such as iso-apl or apl2. results show the influence of the cost of syntax analysis in the processing of apl expressions.  jean jacques girardot florence rollin