General Chair: Howard Reubenstein
Program Chair: Dorothy Setliff
The Knowledge-Based Software Engineering Conference provides a forum for researchers and practitioners to discuss applications of automated reasoning, knowledge representation and artificial intelligence techniques to software engineering problems. This conference focuses on specific knowledge-based techniques for constructing, representing, reasoning with, and understanding software artifacts and processes. These techniques may be fully automatic, may support, or cooperate with humans.
This year, KBSE included one day of tutorials followed by three days of paper sessions and panels. The keynote speaker was Howard Shrobe, from ARPA.
Paper session topics includes Synthesis, Formal Methods, Knowledge-Based Environments, Process, Reuse/Reengineering, and Program Understanding. The best paper award was shared between Lewis Johnson and Ali Erdem's paper titled "Interactive Explanation of Software Systems" and Michael Lowry and Jeffrey Van Baalen's paper titled "META-AMPHION: Synthesis of Efficient Domain Specific Program Synthesis Systems."
In addition, there was one joint paper/panel session on Legal Issues in Knowledge-Based Software Engineering and two panel discussions on Formal Methods in KBSE and Empirical Evaluations of Software Technology. All of the panels resulted in lively interactions between panel participants and attendees.
The Conference banquet was held at the Boston Museum of Science where we all learned the optimal process to ensure the ball goes all the way to the ceiling and honored our General Chair as the Big Kahuna.
This tutorial gave attendees an understanding of the key concepts in knowledge-based software engineering. It identified software engineering tasks that are amenable to knowledge-based solutions, and categorized the various types of knowledge-based systems that may be developed. The current state of the art in KBSE research and development was examined, in each area of software engineering. The key technologies currently being used in these solutions were then examined in detail. The tutorial placed Rome Laboratory's Knowledge-Based Software Assistant program in the overall context of knowledge-based software engineering.
This tutorial examined software development from the perspective of human, cognitive needs. In this regard, two themes were explored. First, usability methods for developing interactive software were discussed. The goal of these methods is to yield software systems that closely match the tasks and sophistication of the intended end users. Example techniques included protocol analysis, the cognitive walkthrough, and heuristic evaluation. Second, an architecture for software design environments was discussed. Some examples of design environments were presented but the emphasis was on the knowledge-based techniques which best meet the cognitive needs of software designers. Example techniques included feedback from critics, explanation through examples, and support for evolutionary design.
Y.V. Srinivas and Richard Jullig presented a full-day tutorial on Specware. About 12 people attended. The tutorial consisted of interleaved lectures and on-line demonstrations. Specware is a system supporting formal system development. Specware is under development at Kestrel Institute. The tutorial introduced and illustrated the Specware notions of specifications, refinements, and sequential and parallel composition of refinement. In the concluding discussion Specware users reported on their experiences and future plans.
This session dealt with formal methods, formal models, formal specifications, and their application towards knowledge-based software engineering. "Representing Object Models as Theories" represented a bridge between the KBSE and object technology worlds, proposing a formal theoretical model for objects and object frameworks. "Logical Frameworks as a Basis for Verification Tools" reported on work that embedded the semantics of the Z formal specification language into the generic theorem prover Isabelle in order to produce a theorem prover for Z-based specifications. "A Transformation System for Interactive Reformulation of Design Optimization Strategies" dealt with knowledge-based software that produces optimal designs for physical objects (such as racing yachts). Finally, "Searching for a Global Search Algorithm" reported on a case study that tied KBSE development techniques with mainstream software engineering life cycle models.
"Empirical Evaluation of KBSE Technology," a panel convened by Bill Sasso of Andersen Consulting, generated a lively discussion of the role and importance of its topic. Vic Basili described a long-term collaboration between the Univerity of Maryland, CSC, and NASA in systematic evaluation of software technology, and Prasanta Bose of the University of Southern California emphasized the importance of hypothesis formulation as a foundation of evaluation. After Lou Hoebel of Rome Laboratory, USAF, presented a case study of KBSA technology's journey from the laboratory to application, Gerry Williams of William Jewell College raised an important distinction between evaluation for the purposes of software science as opposed to evaluation as an incentive for software technology transfer.
The Knowledge-based environments session followed the morning panel on Empirical Methods after a short break, and Bill Sasso presented the results from his own empirical study on the use of the KBSE Advanced Development Model. His study compared using the ADM to that of a "conventional" CASE tool, and showed significant improvements in overall performance of software developers using the tool. He admitted some adjustments needed to be made to the study to improve the reliability, but believed that his work was important in two ways: as a first try in empirical evaluation in this field, and as at least some evidence that KBSA does work.
Next in the session was Greger Linden from the University of Helsinki, Finland, who presented his work on interfacing software development environments. This was one of the many new Eurpoean participants at KBSE this year, in which the point was made yet again that the European Software Industry takes formal methods seriously. His work focused on translating between commonly used theorem-proving based systems (such as VDM or Z) which do not generate code, to those that do (such as KIDS).
The session ended before lunch with a presentation by Enn Tyugu of the Royal University of Sweden of his work on formalizing objects in an object-oriented environmnet. This work was impressive in that it has been going on for quite some time (a decade or more), and has yielded some well tested object packages, and has been used in fairly low level CS courses.
In the Process Session, three papers were presented covering a broad range of process issues. The first paper showed that it is sometimes necessary to perform a fundamental reevaluation (reengineering) of the software development process when injecting new technology, in order to take full advantage of that technology. A case study involving generator technology was presented by Akiyoshi Sato of the NEC Corporation. The second paper addressed the issue of developing appropriate method/tool support when postulating a new software process. A framework to represent and coordinate stakeholders' decision making in the Win Win Spiral process was presented by Prasante Bose of USC. The third paper showed how tool architectures can be founded on broad consideration of activities in all phases of the lifecycle. An architectural framework for the lifecycle of business rules was presented by Daniela Rosca of Old Dominion University.
This was a panel discussion/debate on the limitations and benefits of formal methods.
Waldinger (playing devil's advocate) started by pointing out that while formal methods have been an active area of research for forty years, they have had a negligible effect on software practice. He ascribed this to the difficulty of formalizing a constantly changing application domain; it is always easier to construct software by conventional methods than it is to develop a new application domain theory.
Welty argued that developers of formal methods have paid little attention to software maintenance (or should we say evolution), while in practice maintenance occupies the lion's share of software-development effort. He also complained that formal-methods advocates intimidate their opponents through the use of obscure, impressive notation.
Jullig claimed that the development of large-scale software of the future will be impossible without formal methods and tools. He compared the role of formal methods in software engineering to the role of the decimal number system in conventional engineering.
The discussion was opened to the audience and many views were expressed on all sides of the question. No consensus was reached.
The two papers in the "Program Understanding" session dealt with markedly different aspects of the topic: representation and explanation/documentation. On representation, Chris Welty argued that first order logic is inadequate for representing program concepts because domain knowledge must be viewed as both a part of the program and as a model of the domain. On explanation, Lewis Johnson described a study of typical user questions in an Internet newsgroup and an on-line documentation system for supporting the kinds of questions and user levels identified in the study. Both presentations provoked questions about the ramifications of the work: how the conclusions could be accommodated and how they would generalize.
This session consisted of four speakers: Julian Richardson, Harald Ruess, Adele Howe, and Yves Ledru.
Julian Richardson described a method of optimizing functional programs by transforming data representations utilizing a proof method based upon difference matching and rippling.
Harald Ruess presented a formalization of the "divide et impera" programming scheme within a refinement system based upon constructive type theory, and demonstrated the refinement of a small programming problem such that the proof and program development occurs concurrently.
Adele Howe presented the results of an application of classical planning techniques to the generation of test cases for a commercial command processor language interface.
Yves Ledru described a system for interpreting an executable model of a VDM language specification as a form of rapid prototyping, and illustrated how a form of specification animation may be helpful at several stages within the specification refinement process.