This would be a good book for a second or third course in comptuer science. Even so, seasoned pros should take this book seriously. The reader is assumed to be familiar with basic programming and data structures. The reader is also assumed to be familiar with Java - "development in Java" means that Java is the vehicle, not the topic being taught.

Techniques in this book are a level above the most concrete. It's premise is that any piece of code must be viewed in many different ways; right and wrong answers are the least of it. The book starts with a simple but rigorous set of commenting conventions - it makes one wish for a truly rigorous programming language. For each method, one specifies its prerequisites or assumptions, the set of objects with state chaged by the method, and the specifics of the change being made. The authors focus clearly on ambiguous specification at this level; explicitly undefined behavior has a valid role in many rigorous designs. This leads naturally to discussion of parameter checking, error handling, and proper use of thrown exceptions.

The authors develop a few unusual but critical ideas, including mutability - the possibility that an objects data content can change after creation. In well-disciplined programs, this property has far-reaching implications. Liskov and Guttag involve mutability in equality testing, object identity vs. data equality, and valid naming or indexing.

Encapsulation and data hiding have long been design staples, but the authors' examination keeps the idea fresh. They discuss, from the standpoint of provable correctness, how data exposure puts programs at risk. They also make clear how, viewed with an eye to maintainability, the risks of even read-only exposure of an object's data content. They stop short of discussing true formal verification or industrial practice, though, a decision I think appropriate to the book's level. Readers with deeper knowledge can still appreciate the discussion at its implicitly deeper levels.

By the time the authors address high-level system specification, it seems almost obvious. Without high-level specification, there would be no way to fill in the more detailed specifications that now come naturally to the reader. The authors also address that tricky moment between specification and implementation: the intuitive process of design.

Only the end of the book disappointed me, a half-hearted presentation of design patterns. It seems almost perfuctory, presenting DPs just because it's the done thing, not because the authors add their usual depth to the topic.

I really wish I had more upper-level students and professional colleagues who had been trained according to these authors' program. Their software designs, as students and as professionals, would be stronger and safer if they had.

Finally, a word of caution. This is not a book for beginners or for those who are looking for learning Java syntax for writing toy programs. If you have been programming in a OO language (any OO language)for some time and have been using terms like abstraction, design etc without FULLY understanding them, or if you want to learn how to methodically approach the programming process, this book is indispensable!

Thanks you Prof. Liskov, I learnt so much from your book.

If you'd like to become java expert, buy this book.