Java Design: Building Better Apps and Applets (2nd Edition)

Rating:
Summary: A good, clear, simple introduction to good Java design.
Review: This is what I wrote to the authors: ---- To Peter Coad and Mark Mayfield, let me say that "Java Design: Building Better Apps and Applets" is a terrific book, and written in a refreshingly clear style. I appreciate all that you are doing to help us all make our programs work better. ---- A great starting point for anyone interested in how to design your programs well, before you jump into the coding.

Rating:
Summary: Excellent combination of OO design principles & Java
Review: Being an enthusiastic Java programmer I really appreciated the excellent combination of OO design principles and Java concepts like interfaces. The book provides an insightful discussion of important design issues such as design with composition and design with threads.

Rating:
Summary: Great book on pure and applied OO principles
Review: While most books claim to be "object-oriented", only to leave after iterating though the language syntax and briefly explaining the OO buzzwords, this book delivers on it's promises. "Java Design" takes it's readers through numerous design models and patterns and gives examples and reasons behind each approach. Although the code examples are in Java, the book material is not language specific, and the subject matter can easily be applied to other OO languages. The reader should have at least novice experience in OO coding, as this book explains the "why" instead of the "how". A really good book in order to grasp the big picture of design.

Rating:
Summary: Could have been a really great book....
Review: I had high hopes for this book given all of Peter's work in the past. There is good content in it but it is really in too rough of a form. Almost like finding a needle in a haystack.

This "book" reminds me of what I would see come across my desk during the tech edit phase of the book, not the finished product. The CD-ROM does not add much value other than to the price of the book.

I would really like to see this in a second edition. And lets try to stick with UML notation the next time around!

Rating:
Summary: Confusing book
Review: This book is among the hardest books to follow that I have ever read. I teach Java, and develop Java programming classes and to me this book feels like a (bad) set of class notes put together instead of a cohesive document.

The topics that this book addresses, if you are able to plow though it, are of paramount importance. It discusses specific features of Java and how they affect an application's design (it is probably the only book to do so). However, it requires very careful and slow reading, as it tends to jump and ramble around.

Some of the readabilities issues could have been lessened with good editorial work from Yourdon Press and good use of headings - I place more blame on them than on the authors. The tone of the book is very informal and perhaps this is the reason why it is so distracting.

The book offers and relies for comprehension on many diagrams (using their own UML-like notation, "Coad notation", and every so often an UML diagram).

The CD is worthless - it holds about 3MB of data, 'source' to the java examples is not complete, and use deplorable code formatting.

Despite all this, its Java specific issues make it a must read however painful that may be.

Rating:
Summary: Easy to Understand, Useful
Review: The one-line summary says it all. I found this to be a good balance of theory and practice. The code examples effectively illustrate the concepts. This book is for people who want to write code.

Rating:
Summary: Important topic - not so great java book
Review: All experienced programmers know that good programming is ultimately about good design. Therefore when a book on this topic appears in print that also discusses Java, it is greeted with great anticipation - all the more so considering the glut of shoddy beginner-level Java tomes already saturating the market. Alas, these two authors, despite their impressive credentials, have somehow managed to produce one of the more unreadable and simply annoying Java books yet published. "Java Design" reads like a quick re-write from a seminar lecture transcript with the numerous overheads tossed in (many still hand-drawn) - lot of short sentences, itemized points, diagrams without much explanation, and "sound-byte" summaries. That is to say, this book just doesn't read well. Some sections are just plain tedious to plow through and others border on the incomprehensible. I'm sure that it would all make much more sense if the authors were there with you to answer questions while you read through the various sections of the book or better yet, if they read the book to you with some added arm-waving - but they aren't and the book buyer deserves better than worked over lecture notes. The included CDROM doesn't add much to the book except price. In fact, several items on the CDROM can be freely downloaded from one of the authors' web site (www.oi.com). This web site also has a brief slide summary of the major points of the book which may well substitute for purchasing it. Undoubtedly, If you are already a fan of the Coad O-O methodology (or have taken one of their O-O seminars), this book would make more sense - although not necessarily be any more readable. There are certainly some bits of good design wisdom to be found here if you are willing and able to persevere long enough with it. To save you the agony, here is the basic synopsis of the book: composition (e.g. Java interfaces) good, inheritance bad. However, if you are interested in this topic, and you should be, then consider the book "Design Patterns" by Gamma et al. instead and hope that better written Java books on this important topic appear in the not too distant future.

Rating:
Summary: A good Java design book worth reading
Review: 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.

Rating:
Summary:

OOD for Java Apps: It's A Good Thing
Review:

This book outlines five OOD considerations in relation to Java implementations. The authors begin by applying simple OOA amd OOD techniques to two Java example applications, one business oriented and the other embedded. From there they refine the examples by considering when to use inheritance and when *not* to; how Java interfaces can be used to further design abstraction and enhance code reuse; how to handle threads in a design for a Java application; and how to incorporate object to object notification.

The text is an easy read (I read the entire book during a long weekend) and the examples are well explained, complete with object model diagrams, senerio views and actual Java code implementation. The book's appendix includes a very useful step-by-step summary of the strategies to develop a solid OOD targeted for a Java implementation. In addition the included CD-ROM contains a simple to learn shareware application to create object models and senerio views.

The book doesn't contain an in depth general explaination of OOA and OOD and is therefore excellent for readers who are somewhat familiar with these techniques. Hopefully this is only one book in a series of books to follow that cover OOD patterns and how they relate to Java implementations.

Rating:
Summary: Dear Friend,
Review: Thanks for your kind interest. I hope you'll enjoy reading this on-going series on better software design. Along with the books, please also take a look at: The Coad Letter (free technical newsletter, http://www.oi.com/newsletters.htm), Together Professional (Jolt Award winning design tools, http://www.oi.com/together.htm), Hands-on "Object Models" and "Java Programming" Workshops (http://www.oi.com/ workshops.htm). Best wishes for great success, Peter Coad ([e-mail]) ///// About Peter Coad: Peter Coad is the innovator behind the leading software development method that bears his name. He has co-authored books on all aspects of object-oriented development, including Object-Oriented Analysis; Object-Oriented Design; Object-Oriented Programming; Object Models: Strategies, Patterns, and Applications; and Java Design: Building Better Apps and Applets. Coad is probably the world's most experienced object-model builder: he has developed hundreds of object models to date. He founded Object International in 1986; its mission is "helping teams deliver frequent, tangible, working results." In addition to consulting, Object International publishes development tools, including Playground (a shareware object-modeling environment) and the award-winning Together/C++. Peter's current work focuses on Java-inspired design for building applications in Java or C++. Reach him at [e-mail], or visit Object International's Web site (http://www.oi.com).