Abstract
In the mid-1980s, AI development faced a significant methodological challenge: the choice between rigid, top-down software engineering and the unstructured "exploratory programming" common in AI research. This paper introduces the PLUMber’s Apprentice, a development environment designed for Conceptual Natural Language Processing (CNLP). By employing a "Consistency Criterion," the environment allows developers to evolve high-level abstractions and low-level code in parallel, ensuring that iterative experimentation does not compromise system integrity.
Introduction: The AI Development Dilemma
Traditional software engineering methodologies, such as the "waterfall" model, require freezing specifications before implementation begins. However, in the field of Artificial Intelligence—and specifically Conceptual Natural Language Processing (CNLP)—requirements are often discovered through the act of building the system. CNLP aims to extract meaning from language, which is inherently irregular and full of non-generalizable exceptions.
The alternative, exploratory programming, often leads to a "house of cards" effect: a fragile system where minor changes cause catastrophic failures because the global architecture is poorly defined or documented. The authors propose a hybrid approach that bridges this gap, providing the flexibility of exploration with the rigor of formal abstraction.
The PLUMber’s Apprentice Methodology
The core of the proposed environment is the PLUM (Predictive Language Understanding Mechanism) implementation language. The environment facilitates development across three distinct but interconnected layers:
- The Implementation Level (PLUM): This layer uses "Prediction Prototypes," which are declarative structures defining how to fill "slots" in a concept frame (e.g., identifying the "actor" or "object" in a sentence).
- Abstract Prototypes: This is an inheritance hierarchy that allows developers to group related linguistic concepts. It provides a mechanism for modularization and semantic type checking.
- Abstract Instantiation Sequences: A high-level algebraic language used to describe the global behavior of the system, such as the sequence of predicting frames and filling slots.
Abstract Prototypes and the VMSPLUM System
The power of the abstract prototype layer is best demonstrated through the VMSPLUM system, a prototype natural language help facility for the VAX/VMS command language. VMSPLUM was used to test how the environment handles dozens of interacting prototypes for commands like DELETE, COPY, and PRINT.
As shown in Figure 1, the hierarchy organizes commands (like delete and copy) under a <command-frame> and qualifiers (like since and confirm) under a <qualification> node. This structure allows the system to inherit properties and constraints, reducing redundancy and providing a framework for the "Consistency Criterion."
The Consistency Criterion
The "Consistency Criterion" is the environment's primary innovation. It allows for parallel development where requirements, specifications, and implementation co-exist in partial completion. Unlike traditional models, the Apprentice does not force a top-down or bottom-up order. A developer can start with a rapid prototype and then retroactively build an abstract model to clean it up, or work on both simultaneously. The system automatically flags contradictions between these levels, acting as a safety net against the "house of cards" phenomenon.
Key Insights: Middle-Out Engineering
The authors argue for "middle-out" engineering—starting with a small, working subset of the problem and systematically extending it through abstraction. This approach treats documentation not as a static post-hoc task, but as a living process of executable constraints. These high-level descriptions serve as invaluable aids for developers trying to understand and maintain complex, evolving systems.
Results and Future Work
The PLUMber’s Apprentice was qualitatively evaluated through the development of VMSPLUM. The environment successfully managed the complexity of dozens of interacting prototypes. The Consistency Criterion proved effective at identifying common errors, such as ambiguities where multiple command frames were triggered by the same input, or modifications that broke existing slot-filling logic.
Future work aims to automate system extension by analogy and generate prototype hierarchies automatically through query analysis. Additionally, the authors suggest the need for a more formal assertion language to further constrain system behavior beyond what is currently possible with prototype structures.
Conclusion
By integrating formal abstractions with iterative implementation, the PLUMber’s Apprentice offers a viable path forward for complex AI tasks like CNLP. It demonstrates that the flexibility required for exploratory programming can be reconciled with the structural integrity required for robust software engineering.
Summary updated