intelligent support for the engineering of software (panel paper)  engineers of large systems must be concerned with both design of new systems and maintenance of existing systems. a great deal of effort goes into arranging things so that systems may be maintained and extended when needed, and that new systems fit into the context of existing structures. insight about the support of software engineering can thus be derived by examining how other branches of engineering support their version of the processes of engineering.  before embarking on a design project an engineer must first determine the customer's need. this is always a complex process, involving modeling of the customer's situation, to determine exactly what is essential and what is accidental. the specifications derived from this analysis are the input to the design process. the specifications may be expressed in varying degrees of formality. though mathematical formalism is to be desired because it is unambiguous and because it can be manipulated precisely, existing mathematical technique is usually inadequate to precisely specify the requirements. this means that the specification phase must be part of the debugging loop.  the design engineer first attempts to meet the specifications with some existing artifact. if this fails, he attempts to synthesize an artifact that meets the specifications by combining the behaviors of several parts, according to some standard plan. for example, in electrical engineering, a complex signal-processing system can often be composed as a cascade of simpler signal-processing components - an engineer knows that the transfer function of a cascade is the product of the transfer functions of the parts cascaded, if the loading is correct. such design depends on the ability to compute the behavior of a combination of parts from their specifications and a description of how they are combined. often such analysis must be approximate, with bugs worked out by simulation and debugging of breadboard prototypes.  this design strategy is greatly enhanced by the existence of compatible families of canned parts with agreed- upon interfaces and well-defined specifications. if the family of canned parts is sufficiently universal, the interfaces sufficiently well specified, and if design rules can be formulated to isolate the designer from the details of the implementation of the parts, the family constitutes a design language. for example, ttl is a pretty good design language for relatively slow digital systems. just as the approximations of analysis are often imperfect, the abstraction barriers of the design language are often violated, for good reasons. thus there are the inevitable bugs. these may be found in simulation or prototyping.  one key observation is that all phases of engineering involve bugs and debugging. bugs are not evidence of moral turpitude or inadequate preparation on the part of the engineer, they are an essential aspect of effective strategy in the problem-solving process. real- world problems are usually too complex to specify precisely, even assuming that we have adequate formal language to support such specifications. (imagine trying to formalize what is meant by "my program plays chess at the expert level." or "my music synthesizer circuit makes sounds that are like a fine violin." in any precise way, yet surely such specifications are the meat of real engineering.) and even where one can write very precise specifications (as in "this circuit makes 1/f noise.") such specifications are often mathematically intractable in current practice. even worse, analysis of systems made up of a few simple, precisely-specifiable components such as transistors (here a few exponential equations suffice), or floating-point additions are mathematically intractable. thus engineers, like physicists, make progress by approximate reasoning. linearizations are made, and deductions that ignore possibly important interactions are used to plan designs, with the explicit intention of finding the relevant ignored effects in the simulation or prototype debugging phase of design. bugs thus arise from the deliberate oversimplification of problems inherent in using perturbational methods to develop answers to hard problems. finally, bugs often arise, in apparently finished products, because of unanticipated changes in the requirements of the customer. although these are technically not errors in the design, the methods we have for patching a design to accommodate a change in requirements amounts to debugging the installed system.  software engineering needs appropriate tools to support each of the phases of the engineering process. there must be tools to aid with specification and modelling, with synthesis and analysis, with rapid-prototyping and debugging, with documentation, verification, and testing, and with maintenance of finished products. in addition there must be environmental tools to support the engineering process in the large.  our tools must support the natural processes of problem solving. they must provide precise ways to talk about alternate design plans and strategies. there is no doubt that mathematical formalisms, such as logic and abstract algebra are essential ingredients in such an enterprise, but we must be careful to separate our concerns. mathematical formalisms and technique are rarely strong enough to provide better than very approximate models of interesting physical, economic or engineered systems. sometimes a system that is readily described as a computer program is not easily formalized in more conventional terms. this suggests the exciting possibility that some difficult theoretical constructs can be formally represented as computational algorithms. we can expect to manipulate these as we now manipulate equations of classical analysis. such a paradigm shift is already taking place in control theory. twenty years ago, the dominant method for making control systems was synthesizing them using feedback, and the dominant theory was concerned with the stability of linear feedback systems. in contrast, most modern control systems are microprocessor- based, and the theory is now much more qualitative. moreover, the program for the microprocessor is often a much simpler description of the strategy of control than the classical equations, and one can thus express much more complex strategies than were previously feasible to analyze and synthesize. an even more striking revolution has occurred in the design of signal-processing systems. the nature of the field has changed completely, because digital filters are algorithms.  artificial intelligence research often uses programs as theoretical constructs, akin to equations and schematic diagrams, but with the added feature that programs that embody parts of a theory of the design of programs can be used as tools in the process of theory construction (or software development). the language lisp, for example, was initially conceived as a theoretical vehicle recursion theory and for symbolic algebra. most ai experiments are formulated in lisp. lisp has developed into a uniquely powerful and flexible family of software development tools, providing wrap- around support for the rapid-prototyping of software systems. as with other languages, lisp provides the glue for using a vast library of canned parts, produced by members of the ai community. in lisp, procedures are first- class data, to be passed as arguments, returned as values, and stored in data structures. this flexibility is valuable, but most importantly, it provides mechanisms for formalizing, naming, and saving the idioms - the common patterns of usage that are essential to engineering design. in addition, lisp programs can easily manipulate the representations of lisp programs - a feature that has encouraged the development of a vast structure of program synthesis and analysis tools, such as cross-referencers.  gerald jay sussman