Customer Reviews

Java Design: Building Better Apps and Applets

5 star:		(21)
4 star:		(9)
3 star:		(2)
2 star:		(10)
1 star:		(9)

 

 

This book is about design, and is targeted towards readers who have some familiarity with design patterns but need more experience and want to see how to apply these tools using Java.

Regarding the negative reviews, I think the problem is that people with insufficient background are missing the point of the book. The publisher is partly to blame by placing buzzwords like enterprise beans and swing packages on the cover, whereas these are only tangentially touched upon in the text.

The readers who said they're decent Java hackers (that already suggests a person that won't understand design concepts), and people who thought the books spent too much time explaining inheritance and interfaces, just missed the point. The book wasn't explaining these concepts, but rather how to design using these concepts. The authors are guilty of assuming some OOD background from their readers. This book is not for beginners, though some beginners will get a lot out of it.

I read all of the reviews on this book, and found it disturbing how the ratings for this book could go high and low, with few in between.

I read the book, and found it helped me personally in my efforts with developing in Java. The KISS (Keep it simple stupid) method will survive the test of time.

I kept thinking about the review disparities as I read the book. I think that the reviewers who gave low marks were looking for a different kind of book, that might be more related to Java coding tricks - not sure, as I cannot ask them. However this book focuses on program design, and the reviews on the high side focused on this - which is exactly what I was looking for.

I have programmed in Multiple languages over the last 20 years, and I have been learning Java for the last several months as part of my job. Object oriented programming is not a new concept to me. This book isolated the specifics of the Java languages in creating VERY usable classes within a design.

The book isolates 5 concepts to use in designing an Object oriented Java program, and lays out a solid set of rules that can be used for object oriented design even in languages other than Java.

This book uses UML in a clear and consistent manner that will also help clarify some UML ambiguieties for use in Java design - It clarified some UML ideas that other books expressed in highly convoluted ways (I have 3 other UML specific books) .

My issue with the book, is the software on the CD is not clear on its use, and added to the price without adding a lot of Value. The software on the CD is outdated and not possible to register. (you cannot even download a version that was mentioned on their website as of 07/2000 - the CD has version 2.2 and the mentioned software version on their website was 4.0 - but not available for download from togethersoft). If they cut out the CD and reduced the cost of this book it would be a much better value.

The content of the book, and its use of the Java "Interface" classes was excellent - not one of my dozen other Java books clarified this concept anywhere close to this book and it is on this topic that the book was of the greatest value to me.

I have recommended this to anyone needing to learn how to design their classes and programs - not how to code in Java.

Ok, there seems to be some serious inconsistensies between one reviewer and the next. Some say this book is one-star trash, others say it's a five star gem. Weird, eh?

I needed some serious design guidance at my first real work (not in school-class anymore with a teacher nearby). At first I decided not to buy this book because of some of the bad reviews. I bought couple of other books and got nowhere. Now I read this book too and wham was I surprised! This book is excellent.

I find it very obvious now that the persons who gave this book bad reviews were either not good/experienced programmers at all, thus they didn't notice the actual points the authors were trying to convey at times, or the readers just plain read this book too fast with too little thought. It is easy to read this book without actually thinking, because the book does not look very dry or academic. It lacks the "aura of seriousness" just like the author's other book on Color UML, which some people mistakenly dismiss as somewhat of a childrens' book.

This book is NOT about inheritance. It is NOT about interfaces. It is NOT about notification. Nor about threads. Many people thought it was and, of course they already knew those aspects from any basic Java book. This book is about DESIGNING a program using those features. Every chapter cuts the aspects you have to consider about the topic, into a handful of clear guidelines. Every chapter summarizes listing those guidelines at the end of the chapter. If you make the mistake of just reading through, "Aha, yeah, of course... nice, seems smart..." you don't really learn to use them. When you have read this book, go back to design your software. Now, at every step go through all the chapter summaries an APPLY all the guidelines to every design step you make. Then you'll slowly begin to learn. It will feel as if a lightbulb was lit inside your head. "Oh, THIS is how it's done!"

After some experience, you only need this book occasionally, after making the guideline design steps into routine habits. Your code will reflect this by being clear and very professional quality.

Also, someone complained that only some of the UML notation was used. This is again NOT a book on UML. It is a book on the design process/steps that Coad & Co feel are important. Nobody uses every aspect of UML. It is just too huge a notation language. You need to learn a subset that fits YOUR purposes. Some prefer the "Use Case Driven" approach, some "Feature Driven", and so on.

While there are tons of Java books in bookstores, few of them focus on Java design issues. This book offers the authors' precious experiences with simple rules and examples. In stead of talking extensively about conventional OO principles, the authors take readers directly to the real-world design issues and relate them closely with the Java language features. The book is very helpful for people who want to release the full power of Java and master its OOP. It is easy to read indeed. And it is so practical that I can use the techniques immediately in my projects.

I rate this book as 8, because I think this book would be better if the authors put more refinement effort on it. The content is good, but the writing is rather cursory. Conclusions and rules are thrown to readers without much explanation. It seems that Coad and Mayfield did not expect this book to be a classic of Java design, so they just worked out a how-to manual with some examples to exhibit their understanding of the subject IN A HURRY. Therefor, readers should not be surprised with the errors and free-hand figures in the book. Coad and Mayfield are gurus in OO and Java. They have a lot more to offer; they should work on the 2nd edition and make this book a well-written masterpiece.

Java Design: Building Better Apps and Applets is much improved when compared to its first edition. The topics discussed do indeed allow you to build better applications and applets. While Java-centric, these design issues are relevant no matter what language you use.

Each section provides invaluable strategies and guidelines for evaluating your designs and more importantly - it provides suggestions to evaluate which areas in your design are worth spending that additional design time on. The guidelines and strategies alone make this book a must have for any programmer.

I criticized the first edition because the book didn't flow as well and was a little hard to read. In its second edition the book is a very easy read and the information is nicely presented. All diagrams now use UML.

Buy this.

I read this book a few years ago and I remember it to be
a pretty decent book on design. It doesnt claim to teach you
how to do UML or Java. There are other books specifically for
that. Highly recommended if you want to learn about good design.
Books like these are *rare*. I am not sure what the reviewers who
gave this a low score were looking for in this book.

First things first. I originally read this book many months ago, and I have revisited it many times since. The book remains prominant on my book shelf. At that time, what were my expectations for this book ? I was not an OO application programmer/developer who viewed the world through OO design patterns. I was a "gray beard" systems integrator who was developing an in-depth understanding of "distributed object application server" integration issues with legacy systems. Java was/remains my context in which to master OOA/OOD and coding without the hassles of the C++ environment, but with the benefits of "free" Java IDEs downloadable from the WEB (I especially like the VisualAge Java IDE).

Along with many other books (for example Design Patterns from the 'Gang of Four'), hours of studying and practical coding, I found this book very, very helpful. Since all the other design books were C++/Smalltalk oriented, a Java design book was readily appreciated. Of course, with experience, interpreting C++ code snipets to Java is not very difficult, but at the time I read this book the Java examples were very helpful. Some of the (now in retrospect very basic concepts) clear explanations of "what I know, who I know, etc.", were invaluable.

The book's style is different; somewhat refreshing actually.

I would prefer the book to be entirely on the CD so I could travel with it and use it for reference on occasion.

Before I got Rose, the included software for working with designs was also very helpful.

I look forward to follow on work .... but more advanced this time .... this book has made its contribution.

Thanks again for a very helpful text.

This book was a significant stepping stone in my development in OO thinking.

This book immerses you in the thought process of OO. If you feel that you haven't quite clicked with OO design, and pattern books are leaving you puzzled, then read this - give it a month - then read it again.

The you'll then probably think many of the GoF patterns quite obvious, and wonder what all the fuss was about. For example the Bridge pattern, and the Factory patterns are just implementing plugability concepts of Ch 3.

The OO Programmers obsession with "extending" every class is finally laid to rest with this excellent book, and the case for "composition" strongly presented. Whilst the C++ jury may be out, Java programmers can get on with it. Easy to read and full of real-world examples this is the best design, object-orientated book I have come across. Anyone can learn the syntax and structure of a language but it's how the code is put together that determines the quality of the finished product. Just like you wouldn't let a builder start constructing your new home without a plan and design, you shouldn't do the same with your Java development. When you purchase Peter Coad book you also get added value. Visit his web site and you can subscribe to a twice weekly newsletter, get addendum's and new chapters to the book, a free Java Design Tool. Yes of course he wants you purchase courses, software and his next book but it does feel that he really wants you to be "Building Better Apps & Applets".

To be a good Java programmer, you need to be a good object oriented programmer. And you need to understand the way the building materials of a language like Java shape application design.

Peter Coad does. He's an object-oriented programming guru, whose firm, Object International (www.oi.com), has been engaged in many o-o projects in many industries. He brings a wealth of experience to an analysis of Java from a software designer's standpoint. He knows how messy, brittle, and ugly design starts, and he shows us how to use Java to nip it in the bud. He identifies some basic patterns that maximize clean, flexible, reusable design.

He stresses the use of composition over inheritance. Coad is not big on inheritance: he's seen it misused a lot, and he sets forth clear and limiting criteria for its use. He shows good Java-based ways to compose objects with other objects, preserving encapsulation and expanding flexibility. He also shows intelligent strategies for using interfaces.

In my own current Java projects, Coad's book made a lot of design issues clearer. It's sent me back to the drawing board, but with a much more well-rounded design sensibility.

This is an excellent book for a beginning object-oriented programmer, starting out with Java. It makes clear the appropriate use of interfaces, and points out the pitfalls of multiple inheritance and a number of other practices.

His book comes with a CD-ROM of Playground, Coad's general o-o design tool. His Strategies and Patterns Handbook is also on the CD-ROM, with 177 strategies and 31 object model patterns in .hlp format.

This book is based on JDK 1.0.2. I'm curious about what his take will be on JDK 1.1, especially Java Beans. I think the observations in this book apply to 1.1, but might bear extension in that environment.

I strongly recommend this book. Anyone who has learned Java's basics, but wants to know how to put them together to do good design, should buy it.