Customer Reviews

Program Development in Java: Abstraction, Specification, and Object-Oriented Design

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

 

 

Even though "Java" is mentioned in the title of this book, it is not a book on programming in Java. It is much better than that. Plenty of books exist to teach the syntax of Java already; this book provides excellent discussions on designing good programming modules (e.g. classes) that are cohesive units without undesired coupling to other modules in one's design. The discussions of the concepts of mutability, representation-invariants, adequacy, and object specifications are the best I have seen, and Liskov uses these concepts to show how to build extensible classes. This book also has good information about the whole process of developing software; it does not focus on coding, but it does discuss implementing key concepts using Java as the implementation language.

This book is not the Java version of some C++ book, but is an excellent software design and development book updated to use Java instead of a custom language called CLU that was used in the previous version. Those looking for a book on good Java usage should check out _Practical_Java_ by Haggar or something similar.

Barbara Liskov brings name recogntion the text. Respect comes for reasons, though, and this book shows many good reasons for respecting this educator and her co-author.

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.

This is one of the best Computer Science books I have read. It is one of those books where every word is worth reading. And it is so concise. After reading this book, I understood clearly what exceptions were, how good design is done, etc. Also, the fundamental concepts like abstraction, decomposition, etc are so brilliantly described that you will never be hazy about them again. The most favourite topic of mine is the procedural SPECIFICATION part using the REQUIRES, MODIFIES, EFFECTS clauses. It really helped me see how procedures are specified.

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.

I have some problems understanding inheritance and other OO terms. This book teach not only the meaning of those term but also teach the advantages and how to use them. After reading this book, i know why those term is very important (inheritance, abstraction, etc) and can use it in my programming life.

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

Even though "Java" is mentioned in the title of this book, it is not a book on programming in Java. It is much better than that. Plenty of books exist to teach the syntax of Java already; this book provides excellent discussions on designing good programming modules (e.g. classes) that are cohesive units without undesired coupling to other modules in one's design. The discussions of the concepts of mutability, representation-invariants, adequacy, and object specifications are the best I have seen, and Liskov uses these concepts to show how to build extensible classes. This book also has good information about the whole process of developing software; it does not focus on coding, but it does discuss implementing key concepts using Java as the implementation language.

This book is not the Java version of some C++ book, but is an excellent software design and development book updated to use Java instead of a custom language called CLU that was used in the previous version. Those looking for a book on good Java usage should check out _Practical_Java_ by Haggar or something similar.

Percect book for a computer science student who must learn the fundemantal concepts of Object Oriented Design (OOD) in order to success and able to design and develop production quality software that are reliable, easy to mantain and modifiable.. It outlines the important steps for each chapter but the order of the chapters should be rearranged.

This book was required for a class that I am taking. The copywrite date is 2001 with the current printing edition in 2002. The course instructor refers to the author as a mathematician. This shows in the writing style of the author. Her examples tend to refer to mathematical concepts like sets and polynomials. That's ok, but it would be nice if she could have expanded the examples into other domains. My two big complains so far are the small number of examples in each chapter and her tendency to use one letter names for variables. I don't know what they teach at MIT, but in many other parts of the country they recognized the benefit of longer, more descriptive names in the 1990's (probably earlier). I am only in chapter 5 of a 15 chapter book. Maybe it gets better. Right now I wouldn't buy it if I didn't have to for a class.

Just don't bother with it. Read Stroustrup all the way through and you'll be better off. If you really MUST do Java, read the online Java docs from Sun, starting with the tutorials. They discuss the same things Liskov does but without the idea of specification.

Use a tool like JavaDoc or Deoxygen consistantly through your program and not only have you gained everything else Liskov discusses, you haven't spent time wading through her, often contradictory, arguments on the subject.

Thats not quite fair, if you really do believe that an Object is a model of something in the real world, and not a clever piece of syntax for expressing your logic and enhancing readibility, than you will very likey LOVE this book.

This book cannot be praised highly enough. I liken the experience of reading it to shooting one's self in the face. While reading Liskov doesn't require as much self-will, it is a less-immediate process. How can a suicidal maniac compare to you when his acts only last a moment?

Aside from proving your mental metal, this book can serve two purposes. Read it, and contradict every single idea contained within to the satisfaction of your CS instructor; this may prove hazardous to your health, but will be worth it for your grade. Otherwise, just listen and regurgitate whatever it is the instructor spews your way.

I was disapointed by the abstract nature of the book. Is this just an update to the C++ version to use Java?

I expected a more concrete presentation but the title does suggest Abstraction.

I hesitate to be critical of an expert but it wasn't that useful to me.