When the author of these words started his career as a software developer, “object orientation” was all the rage. “Serious” programming languages were object oriented. “Professional” programming environments allowed one to view “objects” and “classes” in all of their glory. Inheritance, not composition, was the way of the future. Design patterns names were the answer to actual interview questions.
As many other developers, the path of this one started, however, with a humble programming language, sadly not yet dead, called VBScript. In its version 5, released in 2000, this little mutant language featured a somewhat new concept called “classes,” which at that time were more akin to C structs than anything else. These “classes” could not be inherited; well, to be fair they could not even have methods. They consisted of only data fields, and were more or less useful as a way to pass around large amounts of data back and forth from a
Sub to a
Function. In later versions (5.8 being the last one, apparently) this feature grew stronger and more complete.
At that time, however, more interesting things were happening, like Java and its (at the time) clone called C#. Because, honestly, reading Java code starting with
public static void main(String args) was not much more difficult than reading
public static void Main(string args) in C#. Thankfully things got more interesting starting with C# 2.0, released in 2005. But let us not digress.
The priority in 1999 was, then, to learn object orientation (and XML, as well.)
As fate wanted things to be, perusing the shelves of a bookstore in Buenos Aires, this author ended up buying a copy of Grady Booch’s Object-Oriented Analysis and Design with Applications, 2nd Edition (OOADA.) Not a bad choice, actually; after all Booch is one of the authors of UML, so he knows a thing or two about objects. The best part of OOADA is the introduction, drawing ideas from psychology and sociology to explain what classes and objects meant. The final parts, featuring C++ code, are more arcane and difficult to follow for developers new to the language and the concepts (although a more recent 3rd Edition is said to feature Java code instead of C++.)
With hindsight, a much better choice would have been to acquire Bertrand Meyer’s Object-Oriented Software Construction, 2nd Edition (OOSC) instead. Not only because of breadth and depth (as suggested by a quick comparison of the page count, from 500 to 1200) and by language choice (Eiffel beating C++ in readability, particularly for a beginner in the field) but also, and most importantly, because of its style.
Bertrand Meyer is, hands down, the best writer in the computer field, because of a simple reason: his books have both great content and great prose. Not all authors of computer books (and certainly not the one you are reading now) can make the same claim.
OOSC is now considered a historic milestone in the history of object orientation, a major reference on the subject, all while remaining a delightful book to read. In this age where every language incorporates lambdas for the sake of functional programming fashion, this book remains a refreshing experience.
It provides excellent background information in various technical subjects, such as memory management, garbage collection, multiple inheritance, generic programming, type covariance, exception handling, and many other advanced topics. It also includes sections about analysis and style, and even a chapter on “Using inheritance well” and another on object persistence and databases. Needless to say, something many of us would need to read and re-read every so often.
Years later, as the hype of Agile programming methods was getting diluted in the rising reign of DevOps, Monsieur Meyer (still a teacher at ETHZ) published a second gem: Agile! The Good, the Hype and the Ugly (gotta love the exclamation mark, by the way.) This is probably the first serious book ever written about Agile (the second one being the long awaited and recently published Steve McConnell’s More Effective Agile.)
Ironically enough (or not,) Bertrand Meyer is not a signatory of the Agile Manifesto, resulting in a book free of hype or marketing propaganda. It consists of a short (170 pages) enumeration of “pros and cons” of various methodologies, with discussions about their applicability and suitability for certain projects.
In a time where Scrum seems to have become a de facto synonym of Agile, here is a book that actually sheds some light to the subject – and is actually a joy to read (By the way, if you are not interested in reading this book, at least watch this ACM Webinar by Bertrand Meyer himself. You will not be disappointed.)
There is humor in the pages of these two books; there is wit, there is irony. But there is also depth, substance, and reflection. Merci beaucoup, monsieur Meyer.
Cover photo by the author.