Inquire: Predicate-Based Use and ReuseDewayne E. Perry Steven S. PopovichSoftware and Systems Research Center Department of Computer ScienceAT&T Bell Laboratories Columbia UniversityMurray Hill, NJ 07974 New York, NY 10027AbstractThere are four fundamental aspects of use and reuse in buildingsystems from components: conceptualization, retrieval,selection and correct use. The most important barrier to useand reuse, initially at least, is that of conceptualization. TheInscape Environment is a specification-based softwaredevelopment environment (SDE) integrated by the constructiveuse of formal interface specifications. The purpose of theformal interface specifications and the semanticinterconnections (created and maintained as software is builtand evolved) is to make explicit the invisible semanticdependencies that result in conventionally built systems.The important ingredient provided by Inquire inconceptualization, retrieval, selection and use is the set ofpredicates that describe the semantics of the elements in theinterface. These predicates define the abstractions that aregermane to the module interface and describe the properties ofdata objects and the assumptions and results of operations in amodule. Use and reuse of components is based on acomponent’s ability to provide needed semantics — either interms of data object properties or in terms of operationbehavior — at a particular point in a system. It is the purposeof Inquire, the browser and predicate-based search mechanism,to aid both the environment and the user in the search for thecomponents that will provide the desired predicates — that is,the desired properties or behaviors — that are required to buildand evolve an implementation correctly.1. IntroductionThere are four fundamental aspects of use and reuse in buildingsystems from components:• Conceptualization — understanding what is needed;• Retrieval — finding possible components to use;• Selection — determining which of the retrievedcomponents to use; and• Use — using the selected components correctly.Compounding these issues is the fact that use and reuse occursat multiple levels in building systems. Perry and Wolf [13]note that the architecture level is the most appropriate place tobegin thinking about reuse of components because the systemat that point is constrained the least. The process of designnarrows the possible choices because the constraints increasewith each design decision. In this paper, we focus on theproblems of use and reuse where the components are modules,represented by their interfaces. Independent of the granularityof the component, the most important barrier to use and reuse,initially at least, is that of conceptualization — that is, ofunderstanding the components and their underlying models; inshort, understanding what is needed at any particular place inthe system.The Inscape Environment [8,9] is a specification-basedsoftware development environment (SDE) integrated by theconstructive use of formal interface specifications. Thesespecifications serve two purposes: first, they express the intentof the designer about the externally visible behavior of theoperations described in the interface and define the propertiesof data objects declared and exported in the interface; second,they provide the basis for the construction of semanticinterconnections [8] among interfaces and between interfacesand implementations. On the basis of these two uses, Inscapemakes explicit the semantic dependencies among the variouscomponents in a software system, which are implicit innormally constructed systems, and uses these dependencies toassist in the construction and evolution of these systems.Inscape uses these explicit semantic interconnections in theprocess of construction and evolution in several ways:• to synthesize interfaces from implementations [10],• to detect semantic errors [10],• to determine the implications of changes [8,9], and• to find objects to supply desired behavior and properties(that is, to supply the needed predicates).It is on this last use that we focus our attention in this paper.The important ingredient in conceptualization, retrieval,selection and use is the set of first-order predicates (with typedparameters) that describe the semantics of the objects in theinterface. These predicates define the abstractions that aregermane to the module interface and describe the properties ofdata objects and the assumptions and results of operations in amodule. For data objects, predicates represent additionalinformation not provided by the typing mechanism. This isparticularly important for a weakly typed language such as C.The amount of semantics provided by the specifier in this formis a design issue: what are important semantic properties thatneed to be maintained for the data objects.For operations, predicates represent the assumptions andresults. To some extent, the level of detail provided is a designissue here as it is for data objects: what are the importantsemantic properties embodied in the operations. However, asthe interfaces represent the external behavior of the operation,it is critical that all external state changes be represented in thespecification. Only in local objects should state changes not bereported beyond the operation’s boundaries. Note that in alanguage such as C that has only rudimentary abstractionmechanisms, information hiding is really informationwithholding. Conversely, one has a large degree of latitude inreporting observations about the current state made within theimplementation — though it is usually the case that the moreinformation the better.Use and reuse1of a component is based on its ability to provideneeded semantics — either in terms of data object properties orin terms of operation behavior — at a particular point in asystem. It is the purpose of Inquire, the browser andpredicate-based search mechanism, to aid both the environmentand the user in the search for the components that will providethe desired predicates — that is, the desired properties orbehaviors — required to build and evolve an implementationcorrectly.In Section 2, we discuss the current state of browsers andretrieval mechanisms and indicate their strengths andweaknesses with resect to the four fundamental aspects of useand reuse. In Section 3, we indicate how Inquire differs fromthese mechanisms, delineate the shape of Inscape’s predicate-based search and browse