WorldCat Identities

Waters, Richard C.

Overview
Works: 41 works in 112 publications in 1 language and 969 library holdings
Genres: Conference proceedings 
Roles: Editor
Classifications: Q336, 006.3
Publication Timeline
Key
Publications about  Richard C Waters Publications about Richard C Waters
Publications by  Richard C Waters Publications by Richard C Waters
Most widely held works by Richard C Waters
Readings in artificial intelligence and software engineering ( Book )
9 editions published in 1986 in English and held by 401 WorldCat member libraries worldwide
The Programmer's apprentice by Charles Rich ( Book )
9 editions published in 1990 in English and held by 329 WorldCat member libraries worldwide
Proceedings : Working Conference on Reverse Engineering, May 21-23, 1993, Baltimore, Maryland by Working Conference on Reverse Engineering ( Book )
7 editions published between 1993 and 2002 in English and held by 103 WorldCat member libraries worldwide
A mechanical arm control system by Richard C Waters ( Book )
4 editions published between 1973 and 1979 in English and held by 8 WorldCat member libraries worldwide
Automatic analysis of the logical structure of programs by Richard C Waters ( Book )
5 editions published in 1978 in English and held by 8 WorldCat member libraries worldwide
This report presents a method for viewing complex programs as built up out of simpler ones. The central idea is that typical programs are built up in a small number of stereotyped ways. The method is designed to make it easier for an automatic system to work with programs. It focuses on how the primitive operations performed by a program are combined together in order to produce the actions of the program as a whole. It does not address the issue of how complex data structures are built up from simpler ones, nor the relationships between data structures and the operations performed on them. The plan building methods (PBMs) and the automatic analysis system presented in this report have been developed as part of a larger research project. The goal of this project is to develop a system, called a Programmer's Apprentice (PA), which can assist a person who is writing a program. The purpose of the PA is to make the construction, maintenance, and modification of programs easier and more reliable. The PA is intended to be midway between an improved programming methodology which facilitates good programming style, and an automatic programming system. The intention is that the PA and a programmer will work together throughout all phases of the development and maintenance of a program. The programmer will do the hard parts of design and implementation while the PA will act as a junior partner and critic keeping track of all the details and assisting the programmer wherever possible
XP, a common Lisp pretty printing system by Richard C Waters ( Book )
5 editions published in 1989 in English and held by 7 WorldCat member libraries worldwide
Intelligent assistance for program recognition, design, optimization, and debugging by Charles Rich ( Book )
4 editions published in 1989 in English and held by 7 WorldCat member libraries worldwide
The authors describe research in four related areas, based on the following theoretical principles: The assistant approach (incremental automation) and the exploitation of cliches' (using knowledge of common engineering practice). Each investigation involves the construction of a prototype system to provide intelligent assistance for a person performing the task: A recognition assistant will help reconstruct the design of a program, given only its source code. A design assistant will assist a programmer by detecting errors and inconsistencies in his design choices and by automatically making many straightforward implementation decisions. An optimization assistant will help improve the performance of programs by identifying intermediate results that can be reused. A debugging assistant will aid in the detection, localization, and repair of errors in designs as well as completed programs. These prototypes will be constructed using two shared technologies: A programming language independent formal representation for programs and programming knowledge (the Plan Calculus) and an automated reasoning system (CAKE), which supports both general logical reasoning and special-purpose decision procedures. Keywords: Automatic programming, Programmer's apprentice project. (kr)
Abstraction, inspection and debugging in programming by Charles Rich ( Book )
2 editions published in 1981 in English and held by 6 WorldCat member libraries worldwide
We believe that software engineering has much to learn from other mature engineering disciplines, such as electrical engineering, and that the problem solving behaviors of engineers in different disciplines have many similarities. Three key ideas in current artificial intelligence theories of engineering problem solving are: Abstraction -- using a simplified view of the problem to guide the problem solving process. Inspection -- problem solving by recognizing the form ('plan') of a solution. Debugging -- incremental modification of an almost satisfactory solution to a more satisfactory one. These three techniques are typically used together in a paradigm which we call AID (for Abstraction, Inspection, Debugging): First an abstract model of the problem is constructed in which some important details are intentionally omitted. In this simplified view inspection methods are more likely to succeed, yielding the initial form of a solution. Further details of the problem are then added one at a time with corresponding incremental modifications to the solution. This paper states the goals and milestones of the remaining three years of a five year research project to study the fundamental principles underlying the design and construction of large software systems and to demonstrate the feasibility of a computer aided design tool for this purpose, called the programmers apprentice. (Author)
Optimization of series expressions : Part I--user's manual for the series macro package by Richard C Waters ( Book )
4 editions published in 1989 in English and held by 6 WorldCat member libraries worldwide
The benefits of programming in a functional style are well known. In particular, algorithms that are expressed as compositions of functions operating on series/vectors/streams of data elements are much easier to understand and modify than equivalent algorithms expressed as loops. Unfortunately, many programmers hesitate to use series expressions. In part, this is due to the fact that series expressions are typically implemented very inefficiently. A Common Lisp macro package (called Series) has been implemented that can evaluate a wide class of series expressions very efficiently by transforming them into iterative loops. When using this class of series expressions, programmers can obtain the advantages of expressing computations as series expressions without incurring any run-time overhead. Keywords: Programming manuals. (kr)
Formalizing reusable software components in the Programmer's Apprentice by Charles Rich ( Book )
4 editions published in 1987 in English and held by 6 WorldCat member libraries worldwide
There has been a long-standing desire in computer science for a way of collecting and using libraries of standard software components. The limited success in actually doing this stems not from any resistance to the idea, nor from any lack of trying, but rather from the difficulty of choosing an appropriate formalism for representing components. For a formalism to be maximally useful, it must satisfy five key desiderata: expressiveness, convenient combinability, semantic soundness, machine manipulability, and programming language independence. The Plan Calculus formalism developed as part of the Programmer's Apprentice project satisfies each of these desiderata quite well. It does this by combining the ideas from flowchart schemas, data abstraction, logical formalisms, and program transformations. The efficacy of the Plan Calculus has been demonstrated in part by a prototype program editor called the Knowledge-based Editor in Emacs. This editor makes it possible for a programmer to construct a program rapidly and reliably by combining components represented as plans
Computer aided evolutionary design for software engineering by Charles Rich ( Book )
3 editions published between 1978 and 1979 in English and held by 6 WorldCat member libraries worldwide
This memorandum reports on a partially implemented interactive computer aided-design tool for software engineering. A distinguishing characteristic of this project is its concern for the evolutionary character of software systems. It draws a distinction between algorithms and systems, centering its attention on support for the system designer. Although verification has played a large role in recent research, this perspective suggests that the complexity and evolutionary nature of software systems require a number of additional techniques. Managing of complexity is a fundamental issue in all engineering disciplines. The authors identify three major techniques used in mature engineering fields which seem applicable to the engineering of software systems: incremental modelling; multiple and almost hierachical decomposition; and analysis by inspection. Along these lines they have (1) Constructed a plan library to aid in analysis by inspection (the analysis of a program based on identifying standard algorithms and methods in it); (2) Identified a small set of plan building methods which can be used to decompose a softwre system into loosely coupled subsystems; (3) Developed the technique of temporal abstraction which makes it possible to model a program from a viewpoint which clearly separates the actions of generations and consumers of data; and (4) Developed a dependency-based reasoning system uniquely suited to incremental and evolutionary program analysis. These methods are substantially language independent and have been applied to programs written in several commonly used languages
A hypothetical monologue illustrating the knowledge underlying program analysis by Howard E Shrobe ( Book )
3 editions published between 1978 and 1979 in English and held by 6 WorldCat member libraries worldwide
Automated Program Analysis is the process of discovering decomposition of a system into sub-units such that the behavior of its parts. Analysis can be employed to increase the explanatory power of a program understanding system. We identify several techniques which are useful for automated program analysis. Chief among these is the identification and classification of the the macro-scale units of programming knowledge which are characteristics of the problem domain. We call these plans. This paper presents a summary of how plans can be used in program analysis in the form of a hypothetical monologue. We also show a small catalogue of plans which are characteristic of AI programming. Finally, we present some techniques which facilitate plan recognition. (Author)
LetS : an expressional loop notation by Richard C Waters ( Book )
5 editions published between 1982 and 1983 in English and held by 6 WorldCat member libraries worldwide
Many loops can be more easily understood and manipulated if they are viewed as being built up out of operations on sequences of values. A notation is introduced which makes this viewpoint explicit. Using it, loops ca be represented as compositions of functions operating on sequences of values. A library of standard sequence functions is provided along with facilities for defining additional ones. (Author)
KBEmacs : a step toward the programmer's apprentice by Richard C Waters ( Book )
3 editions published between 1985 and 1986 in English and Undetermined and held by 6 WorldCat member libraries worldwide
The Programmer's Apprentice project : a research overview by Charles Rich ( Book )
3 editions published between 1987 and 1988 in English and Undetermined and held by 5 WorldCat member libraries worldwide
The goal of the Programmer's Apprentice project is to develop a theory of how expert programmers analyze, synthesize, modify, explain, specify, verify, and document programs. This research goal overlaps both artificial intelligence and software engineering. From the viewpoint of artificial intelligence, we have chosen programming as a domain in which to study fundamental issues of knowledge representation and reasoning. From the viewpoint of software engineering, we seek to automate the programming process by applying techniques from artificial intelligence
A system for understanding mathematical FORTRAN programs by Richard C Waters ( Book )
3 editions published in 1976 in English and held by 5 WorldCat member libraries worldwide
This paper proposes a system which, when implemented, will be able to understand mathematical FORTRAN programs, such as those in the IBM Scientific Subroutine Package. The system takes, as input, a program and annotation of the program. In order to understand the program, the system develops a 'plan' for it. The plan specifies the purpose of each feature of the program, and how these features cooperate in order to create the behavior exhibited by the program. The system can use its understanding of the program to answer questions about it including questions about the ramifications of a proposed modification. It is also able to aid in debugging the program by detecting errors in it, and by locating the features of the program which are responsible for an error. The system should be of significant assistance to a person who is writing a program. (Author)
Optimization of series expressions : Part II--overview of the theory and implementation by Richard C Waters ( Book )
4 editions published in 1989 in English and held by 5 WorldCat member libraries worldwide
The benefits of programming in a functional style are well known. In particular, algorithms that are expressed as compositions of functions operating on sequences/vectors/streams of data elements are easier to understand and modify than equivalent algorithms expressed as loops. Unfortunately, this kind of expression is not used anywhere near as often as it could be, for at least three reasons: (1) Most programmers are less familiar with this kind of expression than with loops; (2) Most programming languages provide poor support for this kind of expression; and (3) When support is provided, it is seldom efficient. In many programming language, the second and third problems can be largely solved by introducing a data type called series, a comprehensive set of procedures operating on series, and a preprocessor (or compiler extension) that automatically converts most series expressions into efficient loops. A set of restrictions specifies which series expressions can be optimized. A set of restrictions specifies which series expressions can be optimized. If programmers stay within the limits imposed, they are guaranteed of high efficiency at all times. A Common Lisp macro package supporting series has been in use for some time. A prototype demonstrates that series can be straightforwardly supported in Pascal. Keywords: Sequences; Loops; Program transformations; Functional programming; Optimization
System validation via constraint modeling by Richard C Waters ( Book )
2 editions published in 1988 in Undetermined and English and held by 5 WorldCat member libraries worldwide
Program translation via abstraction and reimplementation by Richard C Waters ( Book )
3 editions published between 1986 and 1988 in English and held by 4 WorldCat member libraries worldwide
Essentially all program translators (both source-to-source and compilers) operate via transliteration and refinement. The source program is first transliterated into the target language on a statement by statement basis. Various refinements are then applied in order to improve the quality of the output. Although acceptable in many situations, this approach is fundamentally limited in the quality of output it can produce. In particular, it tends to be insufficiently sensitive to global features of the source program and too sensitive to irrelevant local details. This paper presents an alternate translation paradigm - abstraction and reimplementation. Using this paradigm, the source program is first analyzed in order to obtain a programming language independent, abstract understanding of the computation performed by the program as a whole. The program is then reimplemented in the target language based on this understanding. The key to this approach is the abstract understanding obtained. It allows the translator to see the forest for the trees - benefiting from an appreciation of the global features of the source program without being distracted by irrelevant details
PP : a Lisp pretty printing system by Richard C Waters ( Book )
1 edition published in 1984 in English and held by 4 WorldCat member libraries worldwide
The PP system provides an efficient implementation of the Common Lisp pretty printing function PPRINT. In addition, PP goes beyond ordinary pretty printers by providing mechanisms which allow the user to control the exact form of pretty printed output. This is done by extending Lisp in two ways. First, several new FORMAT directives are provided which support dynamic decisions about the placement of newlines based on the line width available for output. Second, the concept of print-self methods is extended so that it can be applied to lists as well as to objects which can receive messages. Together, these extensions support pretty printing of both programs and data structures. The PP system also modifies the way the the Lisp printer handles the abbreviation of output. The traditional mechanisms for abbreviating lists based on nesting depth and length are extended so that they automatically apply to every kind of structure without the user having to take any explicit action when writing print-self methods. A new abbreviation mechanism is introduced which can be used to limit the total number of lines printed. Additional Keywords: Formatted Output, Abbreviated Output. (Author)
 
moreShow More Titles
fewerShow Fewer Titles
Audience Level
0
Audience Level
1
  Kids General Special  
Audience level: 0.74 (from 0.47 for Program tr ... to 0.95 for LetS : an ...)
Languages
English (80)
Covers