Generic programming is a technique aiming at writing programs
as general as possible, without sacrificing efficiency by
doing overgeneralization. With the advent of the
(Standard Template Library),
generic programming has got a little boom, at least in the
C++ programming community.
Other related techniques are Adaptive, Aspect-oriented and Generative
Programming (see below )
The following resources may help you getting started in this
research field (note that is somewhat slanted towards applications
in Scientific Computing):
Research groups doing generic programming
Generic Software Components
- Numerical Computing
- Roldan Pozo's
Template Numerical Toolkit for Linear Algebra is a successor to the
The Template Numerical Toolkit is a collection of mathematical libraries for
numeric computation in C++. Its fundamental classes include vectors, matrices,
and multidimensional arrays. The basic goal is to allow one to express
mathematical computation at a higher level of abstraction, while still retaining
some control over performance and optimization issues. Doing so requires a
careful analysis to balance these tradeoffs.
The toolkit provides an integrated collection of generic matrix/vector classes
based on components of the Standard Template Library (STL) and ANSI C++,
- The Matrix Template Library (MTL).
From the page:
The Matrix Template Library (MTL) is a high-performance library written
in C++ that provides comprehensive basic linear algebra functionality for
vectors and for a large variety of sparse and dense matrix formats.
(Generative Matrix Computation Library)
The Generative Matrix Computation Library (GMCL) represents a
comprehensive and extensively documented case study in Generative
Programming. The GMCL makes widespread use of expression templates,
generative C++ programming idioms, and many template metaprogramming
facilities, e.g. control structures for static metaprogramming. The C++
implementation of the matrix component comprises 7500 lines of C++ code. The
matrix configuration DSL covers more than 1840 different kinds of matrices.
the Portable Expression Template Engine
is a C++ class library for scientific
computing which provides performance on par with Fortran 77/90. It
uses template techniques to achieve high performance.
- Geometrical and Combinatorial Algorithms
Boost Graph Library (BGL)
Generic Graph Component Library (GGCL) )
is a general purpose,
generic C++ library for graph data structures and graph algorithms.
From the page:
Graphs are mathematical abstractions that are useful for solving many types
of problems in computer science. Consequently,
these abstractions must also be represented in computer programs.
A standardized generic interface for traversing graphs is of
utmost importance to encourage reuse of graph algorithms and data structures.
Part of the Boost Graph Library is an interface
for how the structure of a graph can be accessed using a generic interface
that hides the details of the graph data structure
This is an ``open'' interface in the sense that any graph library
that implements this interface will be
interoperable with the BGL generic algorithms and with other algorithms
that also use this interface.
BGL provides some
general purpose graph classes that conform to this interface,
but they are not meant to be the ``only'' graph classes; there
certainly will be other graph classes better for certain situations.
We believe that the main contribution of the BGL is the
formulation of this interface.
The BGL graph interface and graph components are generic in the same sense
as the the Standard Template Library (STL).
- the Computational Geometry Algorithms Library. From the page:
The CGAL project is a collaborative effort to develop a robust, easy to
use, and efficient C++ software library of geometric data structures and
algorithms. The CGAL library contains:
- Basic geometric primitives such as points, vectors, lines,
predicates such as for relative positions of points, and
operations such as intersections and distance calculation.
- A collection of standard data structures and geometric
algorithms, such as convex hull, (Delaunay) triangulation, planar
map, polyhedron, smallest enclosing circle, and multidimensional
- Interfaces to other packages, e.g. for visualisation, and I/O, and
other support facilities.
The Graph Template Library - contains graphs data structures and
- The Karlsruhe Library of Algorithms and Data Structures,
contains among others sequences, sets, multisets and graphs.
The Karlsruhe Library of Algorithms and Data Structures (Karla) is an object-oriented
library of data structures and algorithms designed for reuse. The main goal of this
project is to design a reliable object-oriented library of algorithms and data structures.
A library component is said to be reliable if it is both correct with respect to its
specification and robust in the sense that no runtime errors point into the library.
Therefore, a reliable component can only fail if the user violates the pre-condition on its
use. The reliability of library components is considered to be the key factor to achieve
(Vision with Generic Algorithm) -
Computer vision and image processing library.
It's a novel computer vision library that puts its main emphasize
on customizable algorithms and data structures.
By using template techniques similar to those in the C++ Standard
Template Library, you can easily adapt any VIGRA component to the needs of
your application, without thereby giving up execution speed.
Automaton Standard Template Library
Programming Concepts and Techniques (mostly C++)
Conferences, mailing lists and such
Some related issues
Aspect-oriented and Adaptive Programming
Last modified: Wed Feb 28 19:08:47 MET 2001