Software reuse is based on the simple idea, that it is more
economic and even quality improving to make use of proven
components instead of reinventing them when building or
maintaining a system. An important prerequisite for successful
software reuse is the choice of the most suitable components.
Those which provide the required functionality have to be filtered
out of a multitude of existing components. This process must be
simple and quick, because if the search for components were more
expensive than the development of new ones, software reuse would
not make any sense at all. Most approaches for software retrieval
are based on a textual description of the componentsī properties.
At first sight, texts written in natural language are easy to
understand,  but when it comes to precise interpretations one
becomes aware of the gaps between the writerīs and the readerīs
contexts. Furthermore, a description, which is an abstraction of a
component, cannot express all the information a future reader
might be interested in, which renders the search difficult. In
addition, the production of detailed descriptions is costly and
time consuming.

This thesis deals  (1) with the automatic generation of software
descriptions which are not based on texts written in natural
language and (2) with software retrieval which depends on the
descriptions developed in (1). In contrast to natural language
texts, these descriptions are straight, formal constructs which
are decision trees, finite state automata and grammars. Due to
their well defined formal semantics an interpretation by a human
reader is not needed any longer. In our approach test data deals
with the problem in a very efficient way. Although test data do
generally not reveal a complete spectrum of a componentīs
behavior, they specify a significant and genuine part of it.


As test data are employed for generating descriptions of the
behavior of components, the two groups of stateless and
state-bearing components need to be introduced. This entails the
necessity to develop two different analysis techniques. Within the
first technique signatures of stateless components are generalized
and components with similar signatures are gathered in the same
partition of a software repository. On the basis of test data
decision trees are then generated for each partition, which serve
as browsing structures to locate components. The second technique
deals with state-bearing components. Here, finite state automata
and grammars, which are inferred from test data, are being used as
descriptions. When a component is located in a repository with the
help of finite state automata and grammars it can be verified
whether a component behaves as specified.

Both techniques developed in this thesis support the
administration of a software repository and help to locate
components. Starting from test data, they represent substantial
improvements to software retrieval approaches -- even when text
based techniques have already arrived at their limits.