Introduction

Applications sometimes need complex algorithms. But we notice that these algorithms are often conceived by assembling and adapting basic and well-known algorithms. These simple algorithms can be implemented and collected in algorithm software libraries. These libraries provide components to help the developer program complex algorithms. In this class, we will mostly concentrate on libraries that have a focus on algorithms and data structures (such as the examples given below), and applications of scientific nature (for instance, symbolic, algebraic, numeric, or geometric).

There are several major issues with these libraries:

flexibity: the library code must be modular enough that we can use the algorithm in a variety of situations.
ease of use: the user should be able to use the library without constantly referring to the documentation. A number of universal frameworks can be useful here.
efficiency: a number of wrapper layers may achieve a uniform interface, but at the expense of efficiency. The techniques we promote yield efficient code as well.
correctness: the library code should perform the functions described in the documentation. The documentation should be complete and accurate.
design: our criteria revolve around flexibility, ease of use, efficiency. Reaching the right mix and providing the functionality that is most useful to practitioners is difficult.
reuse of the code: the user should be able to reuse his code with various components of the library without having to change the source code of the library. Changes to the user's own code should be kept minimal.

Abstract data types (ADT) are one answer to these problems. Object-oriented design is another. In this seminar, I will present a few techniques extending ADTs to will help us design better software libraries for applications. Mostly, we will explore generic programming as a great paradigm for writing generic, reusable code. We will use generic programming to craft component technology. Another technique we will cover is the use od design patterns.

A majority of these libraries are in C++. Therefore, the class will teach some advanced C++ technique (templates, metaprogramming, expression templates, generic components). We will also learn the fundamentals of library design in a Unix environment (autoconf, make, documentation).

For examples, we will look at a few successful libraries:

STL: Standard Template Library
MTL: Matrix Template Library
GGCL: Generic Graph Component Library
LEDA: Library of Efficient Data types and Algorithms
JDSL: the Java Standard Data structures Library
CGAL: Computational Geometry Algorithm Library
Blitz++: Object-Oriented Scientific Computing Library
OpenGL: Graphics Library (an open standard)

The class will be in the forms of seminars. If you are a developer, you are invited to present your own problems, libraries and discuss them in class. I will be very flexible since this is a class in development, and I will accomodate any special wish you may have.