Subject: CCL:Object-oriented means for computational chemist/programs structure and design

From: Fabien Campagne <[email-masked]>
Date: Mon, 28 Jul 1997 14:06:27 +0100

On Wed, 23 Jul 1997 18:08:13 -0400  David E. Bernholdt wrote:

>On Tue, 22 Jul 1997 07:45:08 +0000 "Ping Du" wrote:
>> Inheritance is pobably the most important feature of 
>> OO design if you would like your program to be extensible and 
>> reusable.

>I don't entirely agree. Having done OO _design_ and implemented those
>designs in "non-OO" languages, I believe that the other principles of
>OO design (abstraction, encapsulation, modularity) are probably more
>important and more powerful. I have not encountered a case where I
>felt at a serious disadvantage because the languages I was using did
>not support inheritance.

>But in any case, I must stress the importance of design. Looking

A good reference for fortran programers about program structure
and design could be:
Structured Design
Fundamentals of a discipline of Computer Program and
Systems Design
Edward Yourdon/Larry L. Constantine
Yourdon Press Computing Series
ISBN 0-13-854471-9

I didn't read this book carrefully myself, but browsed
it reading some chapters. This was enough to make me
regret that computational chemistry codes have not
been design with the principle it describes in mind... :-(

This book was written before the idea of object oriented
programming ever appeared, with examples in fortran 77.
It may still help people who want to go on with fortran
to design their code in a reusable way, with less defaults
(at the time of development and latter).
Because it does not tell you about OO it's certainly 
more suited to fortran programming. Fortran is a language 
that does not enable to represent an OO design in a 
natural way, whatever you could say: you may sill emulate
the behaviour of an OO language but you will lose a lot
of tools and features available by default in OO languages.
This lack could make the implementation of an OO design 
more difficult. 

>back, I think that a thorough design phase probably allowed us to find
>the right abstractions so that inheritance was really not an issue,
>and we could do what inheritance was required "manually". It also may
>be a property of the problem to some extent (in our case a broad
>spectrum of electronic structure methods).

The choice of the language usualy depends on what you're
ready to do "manually" or not. I learned a nice assembly 
language ten years ago, but today, I'm not ready to implement
methods well described by the OO formalism using assembly
language. It would be painful, and time consuming, even if,
of course, that would be possible..

Fabien Campagne -- [email-masked] | Lab. de Chimie Theorique
phone: +33 (0)3 83 91 20 00  extension 3236 | Nancy, France.
           http://www.lctn.u-nancy.fr/viseur/FC.html