Rating: 
Summary: 1250 pages of theory and practical implementation
Review: A complete book about object orientation for the first time user and the advanced programmer? When looking at the contents list it almost looks like that. Unfortunately the writer could not explain every detail on his 1250 pages. The first two parts about the meaning of object orientation and how to describe the models using this methodology are clear. The third part (referred to by the writer as the 'technical core') focuses in my opinion too much on the semi-code and less on the how and why. But the saddest is the fourth part. In only three pages is explained how to find classes, techniques for inheritance and interfaces.
Rating:
Summary: Don't be put off by some aspects of this book...
Review: A couple of aspects of this book might lead you *not* to read it. That would be too bad, since it contains valuable informaton. Specifically:(1) it spends a lot of time discussing particulars of the Eiffel language or the considerations leading Meyer to design Eiffel as he did. Observation: Even if you skip these parts, you could find useful information in the rest of the book, and many people may enjoy these insights into Meyer's approach. (2) the attitude is often rather dogmatic and judgmental. As one authority commented on the first edition, it "tends to confuse Eiffel with universal principles." Observation: though unfortunate, this does not detract from the value of the content. Further comments: (3) If you don't know any object oriented language, the book is a natural choice, since it is very clear and does not require prior knowledge of any particular language. (4) If you know another OO language, especially C++, you may get more for your time and money by choosing another book, at least to start. But you still could find valuable material here. For alternatives, you might check out the comments on Gamma's Design Patterns and Martin's Designing Object-Oriented C++ Applications: Using the Booch Method, or standard books by Booch, etc.
Rating: 
Summary: Bertrand Meyer's view on all things "object oriented"
Review: A good book, perhaps, for those who want to learn Eiffel (or, as the author simply calls it, "the notation") and why it is the only language that truly supports object oriented software development. This book is certainly not a comprehensive overview of the subject nor a fair or accurate depiction of non-Eiffel languages and techniques. I found Mr. Meyer's style both grandiose and pedantic. The book could also use some editing by a native English speaker. But hey, you get a free demo version of Eiffel on the CD.
Rating: 
Summary: A case of the Emperor's New Clothes?
Review: Everyone seems to be tripping over one another to praise OO and how this book is being presented as the shining gem of this field. But I couldn't get past the first few pages as I CAN'T figure out what the whole point of the subject is! I can appreciate the power of objects (say in a language like Python or Java) but Eiffel (and this book) takes it way too far from programming realities. Maybe this book and Eiffel will be much more suitable for those who are designing REALLY large systems (i doubt it though since if it sucks at small things then more so far large right?) where all the dense OO concepts might be more applicable but as for me, I'm willing to unload this book to whoever wants to buy it from me for half the price.
Rating: 
Summary: Awesome
Review: Few, _VERY_ few authors are as knowledgeable, talented, and fun to read as Mr. Meyer. Compared to the dry, repetitive books by the Rational people, this is a source of relief! _Not_ dogmatic at all, definitely not Eiffel centered, although he uses the language as the notation throughout the book, BECAUSE that's the way he proposes to avoid analysis-to-design-to-implementation-gaps. It's worth every minute reading it, IMHO.
Rating:
Summary: A Metaphor of Brilliance
Review: I agree with all the other positive comments made about this remarkable book. However, as I read the pages, I find myself often adjusting the angle at which I am holding the book. The pages have a shiny surface that can make reading it somewhat difficult. This experience may be a metaphor regarding the book itself. This book reads as fine literature. In an age of tight budgets, fast food and discount superstores, its brilliance may in fact get in the way of the content Bertrand Meyer is communicating. While I personally appreciate the way in which it is written, some students of software engineering may find its eloquence to be a distraction. Having written this, my only suggestion is that the third edition be printed on less shiny paper. I would not hope that the next edition of it become yet another "how-to" book. Bruce Neubauer Pittsburg State University
Rating:
Summary: How can you say enough to reward excellence?
Review: I have two 3M notpad leafs stuck at the periphery of pages 3 to 278. They are labeled Curious and Enlightened, respectively of course. People that walk into the office asking about what OO design is about, get the tattered Meyer paperback and the instruction to come back when they have read these pages. For practical example, they are steered to the rest and works of others. This a special tag on the page about Polymorphism, which is the kind of ambigous term that begs to be forgotten. However, Meyer's lucid brevity makes the meaning stick. The feature I find most special is the pull down menu style outline quality of these pages. Abandon your highlighters with this book. Meyer has already digested and illuminated the key concepts for you. Fortunately, this does nothing to diminish the surrounding text. High marks for editing quality and concept density in a book which clearly pays for itself a third of the way through.
Rating:
Summary: Brilliant -> This book is highly underestimated
Review: I stumbled upon this book 5 years ago when trying to find out more about C++ exceptions. I remember reading a couple for a few hours in the bookstore thinking "there is something deeply important about what is written, but I don't quite understand it yet. I better read this entirely."
--------------------------------------------------
Starting from the very beginning chapter, Genesis. First principles. Precise definitons. Rules. Rationality, Machine-like. He's on to something. This could get really interesting! eg.
Hmmm chapter 5. What's this "basic triangle" and "forces of computation" stuff? They never mentioned *that* in other books. Is this threading? COM? Distributed systems?
Ummmm...wait...It describes them ALL. Let me think about that implication of that a little more. Profound. Chapter6, ADT's, looks straightforward: TYPES FUNCTIONS AXIOMS PRECONDITIONS. Huh?..I am going to reread this one again. hmm,and again...and again for good measure. Wait a minute. Does he really mean *any* abstraction? (Let me check: Relational algebra? a matrix? Stack? Tree? a Window? Quark?) Holy .... Incredible. Why didn't anyone tell me this before?
Western thought in a few pages. Chapter after chapter: Design by Contract, genericity, typing...
How can I put this book down?
------------------------------
I came away from this book a matured, deeper thinker, after many re-reads in conjuction with other books. It transcends computer science by a long shot. (I once tried to lend this book to another programmer, and explain its importance. The first thing he did was go the very end and read the critique of Java for 5 minutes, and dismiss the entire book...)
--------------------------------------
My conclusion:
1) Think (anyone)
2) Create a formal model of your thoughts (Meyer)
2) Manipulate the model with precision (Knuth)
-------------------------------------- This book is a must-read.
Rating:
Summary: Object Oriented Software Construction
Review: I wanted a general text which analyzed the use of Object Oriented Programming, discussing good and bad approaches etc. and a title like "Object-Oriented software Construction" seemed very promising. However I am disappointed. This book is not it. Mr Meyer certainly knows a lot about object oriented programming and the book certainly covers a lot of ground with respect to object oriented programming. However one soon gets the feeling that something is not quite right; that the book is not really a general text on OOP. Mr Meyer clearly has strong biases with regard to the many choices involved in Object Oriented language implementation. There seems to be a clear path emerging and that Mr Meyer is going to shepherd you down his chosen path come what may. I eventually concluded that the book describes his journey through the maze of object oriented programming to justify his development of the Eiffel programming language. What made me come to that conclusion? For a start, the almost constant denigration of all things that he doesn't agree with. I doubt that there will ever be a 'perfect' computer programming language; one which does everything better than any other language. All languages are compromises to some extent in some areas. These compromises mean that all languages have good and bad points, and in an excellent object oriented programming book I would expect discussion to reflect this. However in this book, Mr Meyer is quite dogmatic about most such compromises and these are presented as the only possible 'reasonable' choice. He then dismisses the alternative as being less than perfect, and makes light of the difficulties with his own choice. The book is riddled with these dogmatic assertions. While the author could have written a major general text he chose not to. And that is the major problem because after a while one starts wandering whether what is written is actually a good description of OOP in general or just another biased justification. It is difficult to tell and the author certainly doesn't give any help. One needs to be a really proficient OOP programmer who knows a variety of languages to differentiate. So much so that if you could tell, you wouldn't have much use for the book in the first place. The (English) language and style the author uses clearly indicates that he has an axe to grind and of course the message comes in the last chapter. It is to 'sell' his programming language 'Eiffel'. In the end I realized that the book is really one big advertisement/justification. It reminds me of one of those advertisements for Coke. You think the film has started with all this glitzy action sequences until right at the end the character takes a long swig and you realize that he is holding that recognizable bottle and that you are still in the ads. At least in most ads a company generally makes it clear that it is trying to sell something. In summary I think that the title "Object Oriented Language Construction: The road to Eiffel" would be much more accurate. I certainly do not think the book is a good general reference for object oriented programming. Perhaps useful as one of a dozen which could put some balance back into the discussion.
Rating:
Summary: Dragonbook
Review: I would like to call this book the "dragon book" of Object-oriented programming. As many programmers already know, 'Meyer' is the bible of OOP. The fact that many OOP books quote 'Meyer' attests it. Some people may say Meyer is old, no longer useful. But, I think Meyer is still the best book. Although many OOP languages come out, the basic concept of OOP has not changed. It is just wasting money to buy another book of OOP instead of this book. Do you want to not just know but study OOP? Must have it at first.
| 
