Customer Reviews

Object-Oriented Programming via Fortran 90/95

5 star:		(1)
4 star:		(0)
3 star:		(0)
2 star:		(2)
1 star:		(0)

 

 

This is a great book for any Fortran programmer (new and old). The author does a fantastic job of introducing OOP for Fortran 90/95. I had no idea that all kinds of neat OO concepts could be implemented in Fortran. I almost want to go back and rewrite my big FEA code using these concepts.

What I like most is that the author contrasts implementation details between Fortran, C++, and MATLAB to futher enrich the topics being discussed. Obviously, with this style, the author knows his audience (engineers and scientists).

I HIGHLY RECOMMEND THIS BOOK!

This book requires that the reader already knows about object-oriented programming. It gives little information on the subject. Instead, it gives details about how to use Fortran to implement those concepts. The details it gives will already be familiar to Fortran users, though not for that purpose. I was hoping for a book for the many scientists and engineers who have learned and used Fortran well, but who have not learned about object-oriented methods. This book isn't it. The only audience for which it is useful is the opposite: an experienced object-oriented programmer who wishes to switch from another language to Fortran.

The above occupies about a third of the book. Another third consists of elementary material that is not particularly relevant even to that audience, such as memory management, linked lists, and linear algebra. Object orientation is mentioned only peripherally in that material.

The last third consists of appendices that are mostly padding. There are language tables that are available in the manual with any compiler, and source code which repeats with variations examples in the main text.

This book is quite nice for the spoiled programmer who has been using a modern OO language such as C++ or python, and demonstrates methods to implement OO concepts as classes, overloading and polymorphism in Fortran 90/95 (F9X in the remainder of this review)

This however is also its main weakness: Even though F9X can be forced into these concepts, using those concepts, especially the proposed polymorphism method, is a tedious task, and makes a lot of the magic of OO programming disappear.

What is lacking in this book is an explicit overview of concepts which cannot be implemented easily in F9X, such as destructors, interfaces and inheritance, as that might be reason enough to forget about trying to implement your program in F9X.

My main conclusion after reading this is that trying to do OO in F9X is incomplete and way too much trouble, and thus the need for this book is rather limited.