The software development approach based on Generic Components aims at delivering software solutions that -- despite of relying on the reuse of components -- are customized to the settings in a specific application domain. The approach combines tool-supported techniques for reusing pre-fabricated software artefacts with the goal of producing efficient and therefore specialized software. Such a combination is only possible by extending on the conventional notion of component techniques. To this end, the following concepts are used:
 

Generic software components

Techniques for variable, so called generic component implementations are a prerequisite for our approach. Generic components are software modules allowing to choose their properties to a certain degree without necessarily having to manually change code. The change of properties can concern both functional and non-functional aspects. Examples are the customization of the component's interface (method names, parameters, ...), choice of data structures to work with, tailoring of resource requirements, or the choice of algorithms. Our research is focused at providing such flexibility at the development time of the runtime platform, i.e. at compile time, when appropriate tools can generate the component's source code or apply necessary changes to it. A generic component generally comprises a variety of documents, each describing specific aspects of the component: interface, behaviour, non-functional properties such as execution times or memory requirements, or an informal overall semantic description.

One important aspect of a generic component is the description of its variability. To this end, generic components carry generic parameters being kind of "placeholders" for specific properties that are left variable in the component. A generic parameter can, e.g., be a placeholder for a simple integer value denoting a buffer size, a placeholder for a component interface, a specific algorithm from a set of given choices, or -- in the most complex case -- a placeholder for arbitrary code. A generic parameter represents one dimension in the "space of variability" of a generic component (see also: the design space for a component). The entirety of generic parameters together with the ranges of allowed values express the spectrum of possible variants that can be generated from a generic component (although in most cases not all combinations of parameter settings will be sensible and allowed).
 

Generators

Since the variability of generic components can go beyond what is directly supported by programming languages and conventional software development environments, there is demand for techniques to generate component code from some kind of higher level description. The techniques deployed are closely related to the three types of generic parameters: selection parameters, generative parameters, and code parameters.

Selection parameters are used to select discrete entities from a finite set of possibilities. Entities in this sense are pre-fabricated variants of parts of a component -- data structures, algorithms, or other pieces of code. If a generic component encompasses variants that have completely different implementations, entities can in a broader sense even be whole (sub-)components. The techniques to support this kind of generic parameters are separate source files and appropriate pre-processors allowing to select and possibly exchange certain blocks of source code.

Generative parameters are inputs to tools that generate or modify appropriate solutions in a more flexible way. In simple scenarios, the generation process can consist of merely adjusting a conventional parameter to hold a specific value, duplicating a component instance for purposes of fault tolerance, or changing the name of a method. More sophisticated generators produce code from higher level descriptions such as an SDL specification. The generators to support this kind of generic parameters are in most cases highly specialized. Most of them build on pre-processors in order to include modified code in the source files.

Where the first two types of generic parameters cannot offer enough flexibility, code parameters allow for -- in certain limits defined by the implementor of the component -- arbitrary user-defined code to be inserted into pre-defined gaps. A simple example might be a user-defined data structure, encapsulated in an object implementing a pre-defined interface of access methods. Support for this kind of parameters mainly relies on the techniques for generic programming offered by the programming language (e.g., object-orientation, inheritance, templates, casting, etc.).