
FEI contains quite a lot of very old code. The project began in 1997, just
about the same time that C++ was standardized. At the time, C++ compilers
didn't uniformly support the standard.
 - At least one compiler (an early IBM/AIX compiler) didn't initially support
   namespaces.
 - A couple of compilers didn't initially support the bool type.
 - Some compilers provided <iostream.h> instead of <iostream>, etc.
 - Several compilers didn't have very good STL implementations.

Thus, if you examine the FEI code, you'll notice a number of things:

- Many classes are in a namespace, many are not. Basically, the original
  collection of FEI implementation classes were not put in a namespace. Some
  of them have been migrated into a namespace, and in recent years all new
  classes have been created in a namespace.

- Macros like FEI_COUT and FEI_ENDL are used instead of std::cout and std::endl.
  This is because cout and endl weren't always in the std namespace, so these
  macros are defined appropriately, depending on the C++ implementation being
  used. These macros are defined in base/fei_iostream.hpp.

- There are two primary namespaces: fei and snl_fei. Originally the intent was
  to put abstract interface classes in the fei namespace, and concrete
  implementation classes in the snl_fei namespace. (With the assumption that
  other non-SNL implementations of the abstract interfaces might exist.) But
  it turned out that our implementation was the only one, and all implementation
  classes are now being migrated into the fei namespace. The snl_fei namespace
  still exists, but as time goes by it will contain fewer and fewer classes.
  Certainly all classes that are intended to be part of the public interface
  (i.e., not just implementation details) should be in the fei namespace.

- In some cases (especially in test input files) you'll see references to the
  "old fei" and "new fei". Originally FEI was a single large interface that
  managed all aspects of linear system assembly and solution. This soon
  suffered from growing pains as more and more features and use-cases were
  added. A modular collection of interfaces was developed, each representing
  a logical entity such as a VectorSpace or MatrixGraph, etc. This
  collection of modular interfaces was referred to as the "new fei", while the
  original monolithic interface was referred to as the "old fei". The original
  "old fei" interface still exists, and is declared in base/FEI.hpp. There
  are two implementations of it, base/FEI_Implementation.{hpp,cpp} and
  base/fei_FEI_Impl.{hpp,cpp}. The latter implementation basically provides
  the old interface but uses the newer modular objects internally for the
  implementation.
  This is admittedly confusing. Most users (especially new users) should 
  simply look through the example programs in example/beam and example/poisson
  to learn how the "new fei" is used, and completely ignore the existence of
  the "old fei".

