JavaRanch Book Reviews

Your search returned 58 matching documents

IT Architectures and Middleware: Strategies for Building Large, Integrated Systems by Chris Britton
Addison-Wesley Professional 1 edition December 2000 336 pages	Reviewed by Ajith Kallambella, December 2001 (10 of 10) An excellent coverage of what's, why's and how's of middleware technologies. The book gives an interesting perspective into the growth of middleware solutions with special focus on enterprise systems architecture and distributed technologies. The long journey that begins with TP monitors and primitive "transaction machines" covers a great deal of ground outlining the need-driven evolution of various middleware alternatives and ends with the discussion of latest - the EJB, .NET and CORBA. There is a special emphasis on the changing landscape brought about by the rise of eCommerce and the need to manage large-scale enterprise systems. I love the way author drives home some very complex concepts. This book can serve as an indispensable resource both for beginners and experienced professionals. While the novice can easily comprehend intricacies of IT architecture, experienced architects will find a lot of food for throughout and new insights into many issues. I personally had many "ah, what a brilliant idea" moments. You will find many useful and perhaps unconventional solutions to practical problems. It can even help an IT manager to understand the real middleware and IT architecture issues and to make intelligent decisions without having to get deep into technical waters. Overall, this book is a must have and deserves 10 horseshoes. Discuss book in the Saloon — More info at Amazon.com
Applying UML and Patterns by Craig Larman
Prentice Hall PTR second edition July 2001 656 pages	Reviewed by Junilu Lacar, June 2002 (9 of 10) Craig Larman has outdone himself. This edition, with its many changes and new sections, is really almost a rewrite rather than an enhancement. This edition uses the Unified Process (UP) as a sample iterative process, replacing the first edition's generic set of Recommended Process and Methods (RPM). Many of the changes in the text and diagrams revolve around this shift. If you don't use UP, don't worry: the material is still very relevant since the basic ideas can apply to any iterative development process. Java programmers will also feel right at home since the code examples are in Java. If you use another object-oriented language, you should still be able to follow the discussion. Larman expands his discussion of object-oriented design principles and the General Responsibility Assignment Software Patterns (GRASP) introduced in the first edition, particularly the "Don't Talk to Strangers" pattern which has been incorporated into the more general "Protected Variations" pattern. Other changes include updating use cases to follow the approach popularized by Alistair Cockburn and including a third iteration in the POS System case study. My favorite addition was the new "You Know You Didn't Understand..." sections. They listed common misconceptions about various UP concepts-" a useful aid to quickly review your understanding of the preceding sections. If you read the first edition, you'll probably want to read this one, too. Highly recommended for anybody who wants to learn the basics of UML and iterative OOAD. Discuss book in the Saloon — More info at Amazon.com
Java Enterprise Design Patterns: Patterns in Java Volume 3 by Mark Grand
Wiley unknown edition February 2001 416 pages	Reviewed by David Vick, April 2002 (9 of 10) This is an very well-written book on Enterprise design patterns. Mark Grand presents his topics very clearly and describes each pattern he discusses in detail. The book starts with a thorough tutorial on UML that provides many different examples of the various diagrams and elements, and how they are used together. This part of the book is a good foundation for the balance of the book, which uses UML diagrams in each pattern description. The book is logically divided into different sections based on the common uses of the patterns described. Then each pattern description is broken down into various parts. Mark does an excellent job of focusing in on the various things that affect the pattern in use. He also uses real world examples to describe usage instead of the usual contrived ones found in many books. This is a book that you will read once then use each time you are implementing a pattern to see what you've missed. From an educational point of view, the book is very good and will teach you a lot about the patterns in it. From a development standpoint it may be even more valuable in that it can be used as a reference to get alternative ideas or to see what consideration you may have missed in your implementations. I highly recommend this book to anyone doing enterprise work now or in the future. Now I have to go out and get the first two volumes!!! Discuss book in the Saloon — More info at Amazon.com
Applied Java Patterns by Stephen Stelting, Olav Maassen
Prentice Hall PTR 1 edition January 2002 608 pages	Reviewed by Michael Ernest, March 2002 (9 of 10) If you're unsure how to apply design patterns to Java, this book provides a solid, methodical, but gentle introduction to the practice. This guide uses the classic design patterns first decribed by the GoF book. For each pattern, the authors provide a fresh motivation (writing a Personal Information Manager application), and rationale for matching a program feature or function to an appropriate pattern. The book seems best suited for those who need to learn definition and application in Java by example. There's no CD-ROM; bummer. At a $45 list price, I think code-intensive books should offer one. This code is available by FTP, but, since my local firewall prohibits that, I find fault with the publisher for the inconvenience. In the interests of full disclosure, I know Stephen and Olav personally. It's a pleasure to see them do what a number of us have been avoiding. This book needed to be written, but doing it well requires the diligence of a methodologist and the patience of a researcher. They've done very good work despite the tedium of building the book. Any aspiring program designers will find their time reading it well rewarded. Discuss book in the Saloon — More info at Amazon.com
Software Architecture: Organizational Principles and Patterns by David M. Dikel, David Kane, James R. Wilson
Prentice Hall PTR 1 edition January 2001 320 pages	Reviewed by Carl Trusiak, November 2001 (9 of 10) You might ask if a book devoted to Organizational Principles and Patterns on Software Architecture is really necessary. I didn't think so until I read this book! I quickly found myself nodding as I recognized patterns from the book that we practiced at work. I was also alarmed at the number of Anti-Patterns we have as well. This gives me a goal and guidance to help guide things, hopefully, along a successful path. Besides my enlightenment, the book mainly covers the VRAPS Principle (Vision, Rhythm, Anticipation, Partnering and Simplification Patterns) with real world case studies from organizations such as Allaire. An extreme amount of research went into the production of this book. The result is obvious. Any company producing software should make reading this book mandatory for their Managers, Architects and Developers Discuss book in the Saloon — More info at Amazon.com
Design Patterns Explained: A New Perspective on Object-Oriented Design by Alan Shalloway, James R. Trott
Addison-Wesley Professional 1 edition July 2001 368 pages	Reviewed by Margarita Isayeva, October 2001 (10 of 10) I was going to say "read this book", put a period and finish my review, but they didn't allow me to. This book is a very well written introduction to patterns. Read it before GoF and Cooper books. Read it after, if you want to understand what GoF and Cooper books are about. I was going to say "this book is more about good design than it is about patterns", but this would be senseless - patterns are good design. This book doesn't teach you how to "use patterns", it does better - it teaches how to find a good design. It maps a conceptual level of thinking about design - "good design principles" with an implementation level that happened to be patterns. Reading about design principles when you do not see how they work on concrete code examples isn't particularly insightful. Looking at good code if you do not understand principles that underlie it doesn't help either - only makes you puzzled why it is designed in such a weird way? The magic of this book comes from mapping and tying together these two levels of thinking. It liberates your mind from thinking on implementation level ("nouns are classes, verbs are methods") and allows you to think conceptually - "see the forest and the trees" in authors words. "At this final stage, the patterns are not longer important... The patterns have taught you to be receptive to what is real" - C.Alexander speaking from the last pages of Design Patterns Explained. Discuss book in the Saloon — More info at Amazon.com
UML Distilled by Martin Fowler, et al
Addison-Wesley Professional second edition August 1999 185 pages	Reviewed by Paul Wheaton, January 2000 (10 of 10) The best book on UML. Oh sure, you can buy the three amigos books, take a few years to read them and if you can stay awake, you might actually retain something. This book is an easy read and answers your practical questions. The author is the same guy that wrote the "Refactoring" book reviewed on this page. He makes any subject come alive. Discuss book in the Saloon — More info at Amazon.com
Enterprise Java with UML by CT Arrington, CT Arrington
Wiley second edition June 2003 512 pages	Reviewed by Thomas Paul, June 2003 (7 of 10) This book takes you through the development of an application from proposal to implementation. In alternating chapters the authors explain the use of UML for a particular step in the development lifecycle and then demonstrate what they just explained to develop a sample timecard system. The best part of the book, which is not significantly different than the first edition, is the first half in which the authors discuss requirements gathering and object oriented analysis. The book is worth the price for this first part alone. The second half of the book has been expanded to discuss new J2EE technologies. The chapters on evaluating technologies are good as far as discussing how to evaluate technologies but the actual analysis is weak as they ignore candidate technologies such as Struts in favor of their own homegrown HTML production framework. They also fail to explain why EJBs are a better choice for their sample application than simply using Servlets/JSPs/JDBC. The final section on design gets bogged down with too many pages of code listings and not enough explanations for the code. Arrington has done a very good job explaining UML although some familiarity with UML notation (or at least a handy manual) would be helpful. If you already own the first edition then you can ignore this edition. If you don't own it then you will definitely want to read this book. This is a must have book for any Java architect/developer doing OOAD. Discuss book in the Saloon — More info at Amazon.com
Wiley 1 edition January 2001 480 pages	Reviewed by Thomas Paul, February 2001 (9 of 10) Trying to develop a Java application without first developing a model can lead to a poorly designed application that fails to fulfill the needs of users, lacks reusability, and is difficult to maintain. The Unified Modeling Language (UML) was developed as an open standard notation to assist developers in modeling OO applications. As enterprise developers we are finding that we are expected to be able to design applications using the UML, explain UML diagrams to our users, or be able to develop applications from UML diagrams. The UML can be difficult and confusing to use and many of the books available fail to clearly explain the proper use of this development tool. "Enterprise Java with UML", by CT Arrington is an excellent introduction into the complexities of the UML. Arrington takes us through the entire lifecycle of a sample EJB application (a timecard system) from requirements gathering to implementation. In alternating chapters he explains the use of the UML (use cases!, sequence diagrams, class diagrams, etc.) for that step in the development cycle and then uses what he just explained to develop the timecard system. Along the way we make technology decisions, develop our design, and ultimately convert our design into actual code. By the time we are done the UML has become a new tool in our toolbox. Arrington has done a very good job explaining the UML although some familiarity with UML notation (or at least a handy manual) would be helpful. This is a must have book for any Java developer wishing to learn the UML. Discuss book in the Saloon — More info at Amazon.com
Refactoring: Improving the Design of Existing Code by Martin Fowler, et al
Addison-Wesley Professional 1 edition July 1999 464 pages	Reviewed by Paul Wheaton, January 2000 (10 of 10) This is currently my favorite book. It has changed the way I do development because it gave words to the way the I was doing things and took me even a few steps further! The book discusses the importance of rewriting code NOT to add functionality, but to add clarity and improved design. There is general discussion as well as a list of specific refactorings. It gives tips on how to stress the importance of this to managers, or sneak it by them if they might not be so understanding. :) I think we are going to hear a lot more about refactoring in the next decade. I found the refactorings to be as useful (if not more so) as design patterns. Discuss book in the Saloon — More info at Amazon.com
Design Patterns Java Workbook by Steven John Metsker
Addison-Wesley Professional 1 edition April 2002 496 pages	Reviewed by Matthew Phillips, July 2002 (8 of 10) If you are a beginner to design patterns, this book is not intended for you. This book is intended as a supplement to on of the other design pattern books and in particular the GoF book. If you have read one of the other books and feel comfortable that you can recognize the patterns when you come across them and feel that you have developed a solid foundation then you do not need to read further. This book is not for you. If you are like me and found that you need to read more to build your design patterns foundation then this book is excellent for that. I found that the best use for me was to read a pattern in the "GoF" and then read the pattern in this book. I did find a few problems with the book. Some of the exercises seemed a little off track for a design patterns book, although they were still good exercises. There were also a few typos. The book is a pretty quick read with lots of diagrams and sample code. Discuss book in the Saloon — More info at Amazon.com
The Pattern Almanac 2000 by Linda Rising
Addison-Wesley 1 edition January 2000 384 pages	Reviewed by Shailesh Sonavadekar, October 2001 (8 of 10) Patterns. The current vocabulary of the high end designers and software architects. There are very few universities offering the M.S. courses on this subject; the future language of the software industry. Eric Gamma et al. started this revolution in 1995. It seems that there is no end to it. The author herself has significant experience in the area of Patterns. The book, as its name suggests, is indeed a very good almanac of patterns. The author has taken truly a lot of pains to collect patterns from varous industries & put them in book form. Many of the patterns I have not heard of. That is one of the greatest strengths of the book; it gives you a bird's eye view of all the patterns used in various industries. Another thing I liked about the book, the author mentions relationships with other patterns, though not with details. The layout of the book was not as appealing & the index takes many pages. The patterns should have been accompained by urls. Some url's are given. But, not all. But the effort is really herculean & the author has done a great job to put it in book form. Please note that the book is not for beginners. It is for users who know & use patterns & want to know more about other patterns. I hope the author will come up with more patterns in the near future. Discuss book in the Saloon — More info at Amazon.com
Design Patterns by Erich Gamma, et al
Addison-Wesley Professional 1 edition November 1994 416 pages	Reviewed by Paul Wheaton, January 2000 (8 of 10) The most popular computer science book of all time. This is the "Gang of Four Book". 23 Design patterns that can be used in any object oriented language. You've probably used a lot of them and never knew it! Now, rather than taking 15 minutes to explain to another engineer what you are trying to do, you can just say "I'll use the state pattern here." Discuss book in the Saloon — More info at Amazon.com
Patterns in Java, Volume 1, A Catalog of Reusable Design Patterns Illustrated with UML by Mark Grand
Wiley unknown edition September 1998 480 pages	Reviewed by Carl Trusiak, November 2001 (7 of 10) Mark does an excellent job of covering not only a few of the more common patterns but also, a good quick overview of UML and the software development cycle. Each pattern is illustrated using UML and has example Java code to demonstrate it's use. While the accompanying CDROM has a little dated software, TogetherJ Whiteboard, Rational Rose 98 and System Architect Trail editions; however, these are great to learn UML. You are also given the opportunity to try each and choose the one you might prefer. The 41 patterns discussed are divided very logically in 6 groupings. I can't wait to get the opportunity to read Mark's volume 2 and 3! Discuss book in the Saloon — More info at Amazon.com
Anti-Patterns / Refactoring Software, Architectures, and Projects in Crisis by Brown, Malveau, McCormick, and Mowbray
Wiley 1 edition March 1998 336 pages	Reviewed by Mark A. Herschberg, April 2002 (7 of 10) If you like pattern books, you'll like Anti-Patterns. What is an anti-pattern? It's a design pattern for bad code. Let's face it, we all see plenty of bad code on the job, this book will help you better identify it. This book, like a pattern book, is a catalog. Each anti-pattern definition is structured like a pattern: Name, Root Causes, Symptoms, Consequences, Anecdotal Evidence, and Refactored Solution. It identifies what the problem is, along with its causes. It goes on to discuss the consequences of the problem and then discusses the refactored solution. As with a pattern definition, it goes into great detail, including such information as exceptional cases. The book contains 3 categories of anti-patterns: software development anti-patterns, software architecture anti-patterns, and project management anti-patterns. The book itself is easy to read. It's entertaining, too, often written with a tongue in check style. The anecdotal evidence provided for the anti-patterns is something right out of Dilbert, funny and accurate. The best review I can give is to name some of the anti-patterns from the book: Lava Flow, Golden Hammer, Spaghetti Code, Stovepipe System, Vendor Lock-in, Fire Drill. Like regular design patterns, you probably recognize some of them, but will be able to better identify and apply the knowledge after seeing it formally treated. Exposure to anti-patterns is just as important as exposure to design patterns. This book is a good introduction to the subject. Discuss book in the Saloon — More info at Amazon.com
The Essence of Object-Oriented Programming with Java [tm] and UML by Bruce E. Wampler
Addison-Wesley Professional unknown edition January 2002 320 pages	Reviewed by David Vick, March 2002 (7 of 10) This is a very basic and introductory book into some of the principles of object oriented programming with a nod to the Java language. The intended audience is for semi-experienced Java programmers or programmers experienced in other languages who want an introduction to object oriented programming. If you are familiar with Java you can safely skip chapter 3. In trying to cater to other languages the book can be misleading in respect to Java. If you are coming from another language, you can just skim that chapter to pick up the basics but they are not fundamental to the rest of the book. Over all the book is a quick, down and dirty, intro to some of the principles of OO analysis and design. At only 266 pages of actual text, it does not have the space needed to go into depth or to even give many examples. The author does do a good job of explaining the basics of UML and the notations used in different UML diagrams. As an introductory text this book is sufficient, but if you are looking to learn more in depth you will need another book with more examples and a more detailed discussion of the various topics. If all you are looking for is the basics or a good start into the subject then this would be a good book to start with. It will give you a solid foundation on which to build your knowledge of OO analysis and design. Discuss book in the Saloon — More info at Amazon.com
Java Design Patterns: A Tutorial by James W. Cooper
Addison-Wesley Professional unknown edition February 2000 352 pages	Reviewed by Thomas Paul, May 2001 (7 of 10) Any Java developer who has read "Design Patterns" by Gamma, et al, has probably tried to relate the patterns discussed to Java programs. This book provides a linkage between "Design Patterns" and Java. Each of the 23 patterns discussed in "Design Patterns" are covered in this book using an example of a Java Swing program. The book opens with a brief discussion of design patterns in general and a quick review of UML, which is used throughout the book. The book then has a chapter for each of the 23 patterns. The book then finishes with an overview of Swing and a case study demonstrating how design patterns might be used in an actual development project. Although the author says that this book is not meant to be a companion book to "Design Patterns," I found that is actually the best way to use this book. Reading the description of each pattern in "Design Patterns" followed by reading about the same pattern in this book helped me to understand each pattern in a deeper way than by reading either book by itself. This book is not, however, the Java version of "Design Patterns". Some of the examples seemed strained to make their point. Also, by limiting himself to Swing, the author missed the opportunity to discuss how to use patterns in server side Java development. In general, however, the book does a good job of explaining design patterns and how to use them. Discuss book in the Saloon — More info at Amazon.com
Pattern Oriented Software Architecture by Frank Buschmann, Regine Meunier, Hans Rohnert et al
Wiley 1 edition August 1996 476 pages	Reviewed by Madhav Lakkapragada, April 2002 (6 of 10) The title "Pattern Oriented Software architecture" suggested to me that the book deals a lot with design patterns for software. Maybe because this book was compared to the GoF book in one of the online reviews at Amazon.com. Somewhere in this thought process I got lost reading this book. Defenitely, the book describes patterns. However, the book gives very few examples explaining the usage of the pattern. It describes the architecture details but with very few code examples. So, I do confess that this was not the kind of book I was expecting based on the title. On the other hand the book emphasises Smalltalk examples, although a handful of examples are in C++. A few others examples regarding client-server design patterns are in Java, since Soket programming is easy in Java, I assume. The book is divided into three sections - Architectural Patterns, Design Patterns and other discussions on pattern systems and the future. It concentrates to a large extent on the Architectural patterns. I felt the book is very dry and theoritical as I read through the chapters. I was looking for a more dynamic approach where I could see code changing due to the application of a patterns. Finally, I must admit its highly possible that this book describes a topic excellently but maybe I just couldn't make that connection. I, personally, could never connect with dry and theoritical subjects. I am rating the book above average giving due credit to the detailed explanations. Discuss book in the Saloon — More info at Amazon.com
Metapattern: Context and Time in Information Models by Pieter Wisse
Addison-Wesley Professional 1 edition December 2000 296 pages	Reviewed by Scott M. Allman, February 2001 (6 of 10) As the author is quick to point out this is an innovative and highly original work in conceptual information modeling. After a formal presentation of metapattern terminology and key concepts Wisse jumps into the middle of several issues in conceptual modeling. For example, the book hopes to explain that an object in context is different from the absolute objects assumed by traditional OO models. The metapattern presumes that an object's behaviors are completely different from one context to another. The metapattern, by emphasizing context over object, enables you to adequately describe the enormous variety found in real life. Traditional OO modelers should be ready to leave behind many dogmas. In the metapattern, time has drastic consequences for objects. In addition, OO designers should be forewarned. The metapattern is not a method for technical design or software engineering. 'Metapattern' is a formalization of context, time and validity in information models. This book is actually several books within one and you ought to pay careful attention to the order you read the chapters. The middle parts compare the metapattern to recent work by authors James J. O'Dell, Haim Kilov, August-Wilhelm Scheer, David C. Hay and Martin Fowler. These chapters supplement the theoretical explanation of the metapattern's most fundamental characteristics. A necessary warm-up before tackling the challenging terminology and concepts in the first four chapters is to read both appendices and the introduction. Wisse's schematic diagrams are simple and elegant but weren't enough. This reviewer wanted additional, concrete explanations of core ideas. Immense value would come from more concrete comparisons and examples. The author's frequent tangential remarks, while doubtless precise and true, were distracting. Frankly, I tried hard to understand the metapattern. I read the book cover to cover, then re-read chapters in a different order, all the while investigating his ideas using concrete examples, as best I could. There were glimmers of excitement as I encountered familiar concepts from metaphysics, epistemology, set theory, information modeling and object-oriented modeling. However, all too often I missed the point of his arguments. Reading does not entail understanding. Perhaps I am too much of a software engineer and not enough of a conceptual modeler. I must apologize to the author, but the fairest thing for me to say about the metapattern is that I still don't understand it. Discuss book in the Saloon — More info at Amazon.com
Java and UML by Paul R. Reed Jr.
Addison-Wesley Professional 1 edition November 2001 504 pages	Reviewed by Ersin Eser, December 2001 (5 of 10) UML Topics discussed in this book stay on a conversational level related to OOAD and Unified Process (UP). A conceptual understanding of the topics occurs at very basic level, but it will not enable you to create diagrams related to this area. UP is discussed extensively throughout the book. Regarding JAVA the author talks (cursory level) about JSP, Servlets, JavaBeans and EJB. Code is included which uses these technologies. If you don't know these topics, you will learn the basic conversational-level knowledge of the concepts. If you already know them, nothing new is added. If you are a developer without OOAD knowledge, this book is a great warm-up book for you. It will encourage you to take the next step. If you are a non-technical reader and trying to understand all these new acronyms, terms, and concepts, this is a great book for you buy it. More info at Amazon.com
Bug Patterns In Java by Eric Allen
Apress 1 edition October 2002 264 pages	Reviewed by Sujatha Rajagopalan, October 2002 (7 of 10) "Aim to write programs that are bug free". It is easier said than done.This book will be of special help to the Java developers and programmers who aim to develop robust programs. As developers and testers of Java applications multiply every day, it would come very handy to give them the symptoms and clues to detect a bug and make sure the code takes care of it smoothly. Several bugs go undetected in the real world due to the lack of time allotted for testing and debugging due to financial and other constraints. The author has thrown light at the importance of unit testing and debugging and explains a scientific approach to the same. He recommends extreme programming techniques to make the debugging process very simple yet sufficient. The core portion of the book has a good structured approach to attach unique names to each bug and explains the symtoms and cure too. The initial part of the book concentrated on why debugging and testing was important. There was a big jump when the author goes into more technical details in Java codes and examples. Thats where the reader who has only a minimum knowledge in Java gets lost. This book cannot be recommended to developers in their learning phase. It focuses only on the audience who are Java literates who have been intensively coding in the same. It can be recommended for those Java programmers who want to become better Sherlock Holmes in detecting bugs in Java ! Discuss book in the Saloon — More info at Amazon.com
Software Configuration Management Patterns by Stephen P. Berczuk, Brad Appleton
Addison-Wesley Professional 1 edition November 2003 218 pages	Reviewed by Ilja Preuss, October 2003 (7 of 10) How can a small to medium sized team effectively work on a shared code base, and still provide stable releases to the customer? That is the question this book deals with. It starts with an introduction to configuration management and patterns. The following 16 patterns provide solutions to common problems and constitute the core of the book. Finally there is a short discussion of popular tools. Parts of the text are a little bit dry and could have made use of more examples. The book also basically confines itself to the use of tools and ignores alternative, organizational solutions. By and large though, it contains well comprehensible information about an important topic. Discuss book in the Saloon — More info at Amazon.com
Learning UML by Sinan Si Alhir
O'Reilly 1 edition July 2003 304 pages	Reviewed by Thomas Paul, October 2003 (7 of 10) O'Reilly publishes a selection of books as their "Learning" series. These books tend to be geared to the programmer or student unfamiliar with a technology who is looking for a good introduction. "Learning UML" is a worthy addition to this series. This book is not a complete introduction to the topic of UML diagrams but for the programmer or student wanting to get a good understanding of the basics of UML this book will serve very nicely. The book starts with an explanation of why we model code and then gives a brief introduction to UML. The author then discusses the most commonly used UML diagrams. Class and object, use case, component and deployment, sequence and collaboration, state, and activity diagrams are each given a chapter. How and why each diagram is used is explained with sample diagrams designed to show the most common usage. There are exercises at the end of the main chapters with solutions for the exercises in the back of the book. The exercises are designed to help you to check whether you have understood the information in each chapter. If you are looking to become an expert in UML then there are other books that will serve that purpose. At a little over 200 pages, this book gives enough information for most students and developers without overwhelming them with the multitude of diagrams that are available in the UML. Discuss book in the Saloon — More info at Amazon.com
Data Access Patterns: Database Interactions in Object-Oriented Applications by Clifton Nock
Addison-Wesley Professional 1 edition September 2003 512 pages	Reviewed by Matthew Phillips, October 2003 (8 of 10) This book is an excellent addition to Addison-Wesley's Software Pattern Series. At some point every software application is going to have to access data. The patterns in this book will be invaluable when its time to write data access code. I really like the book's organization. While you don't need to read it cover to cover, it makes it very easy to do by putting the most common patterns first. Using the decoupling patterns alone will allow me to greatly improve my code. While all of the patterns are written with a relational database in mind, there is no reason why many of these patterns could not be applied to flat files or any other data store. The author left all the patterns open to easy interpretation in that sense. This book is all about documenting data access patterns. If you are new to patterns, this is probably not the book you want to start out with. After you read a more introductory pattern book, you really should consider adding this book to your library. Discuss book in the Saloon — More info at Amazon.com
MDA Explained: The Model Driven Architecture--Practice and Promise by Anneke Kleppe, Jos Warmer, Wim Bast
Addison-Wesley Professional 1 edition May 2003 192 pages	Reviewed by Thomas Paul, October 2003 (7 of 10) If you are interested in Model Driven Architecture (MDA) but you don't have a clear grasp of what it is or where the designers of MDA see it heading then you might want to pick up this brief, well-written description written by three authors who are well acquainted with MDA. MDA is the concept of using models developed using a modeling language (UML) to generate real applications. This book can be seen as a high level overview of MDA and at 150 pages it is a fairly easy and quick read. The authors show both what is available today (not too much) and what might be available in the future (perhaps all applications will be generated from models). The authors do try to make the book practical by showing how you can use modeling tools to at least build skeletons of code that can be the start of code development. MDA brings a new set of acronyms but this book explains each of them without too much pain. So how much of what is discussed here is needed by a typical developer or designer? Probably not too much. But if you want to keep your eye on the future of IT then this book is well worth the read. Perhaps one day writing code will be thought of the same way we think of writing machine language. When that happens you will be able to say you knew it was coming. Discuss book in the Saloon — More info at Amazon.com
Enterprise Patterns and MDA: Building Better Software with Archetype Patterns and UML by Jim Arlow, Ila Neustadt
Addison-Wesley Professional 1 edition January 2004 528 pages	Reviewed by Lasse Koskela, February 2004 (8 of 10) Enterprise Patterns and MDA is the third and latest book related to OMG's Model Driven Architecture. However, as the title implies, it's not all about MDA. In fact, the most significant focus of the book is actually patterns, specifically business patterns and archetypes. The authors start the journey by introducing concepts and techniques such as archetypes (universal, recurring "things") and archetype patterns, and Model Driven Architecture. Furthermore, the authors have dedicated one chapter for describing a technique called Literate modeling (combining traditional visual modeling with an accessible business context provided via a narrative text, for example). Up to this point (vicinity of page 116), the authors' writing style has been flawless, in my opinion, and easy to read. From chapter 4 onwards, the authors have provided a huge pattern catalog for archetype patterns. The catalog has been divided into chapters around archetypes such as Party, Order, Customer, and so on. Each archetype pattern introduces a business context, a high-level overview model, and descriptions of the related archetypes, their properties and related activities. I didn't go through even nearly all patterns in the catalog. However, I feel confident that I will dive into the catalog looking for insight when moving to a new problem domain on a new project. Enterprise Patterns and MDA is a nice resource to have on your bookshelf. Discuss book in the Saloon — More info at Amazon.com
Fast Track UML 2.0 by Kendall Scott
Apress 1 edition March 2004 350 pages	Reviewed by Dirk Schreckmann, May 2004 (8 of 10) As described on the back cover of the book, the target audience of Fast Track UML 2.0 includes folks with previous visual modeling knowledge, perhaps including UML 1.x experience. In the book, the author does not attempt to describe the differences between UML 2.0 and UML 1.x, or to point out the new features. Instead, in a content-packed 161 pages, Kendall, with a "fresh look" at UML 2.0, describes well what a typical developer would want to know about modeling with this improved language. Normally, when a book's title tries to convey that it's going to teach me something "really fast" or "in just XX hours", I won't even pick it up. In this case, from reading a few of his previous books, I trusted that the author, Kendall Scott, had probably put together another good book worth reading, and he did. In this book, I was looking for something that would quickly bring me up to date with UML 2.0, while still serving as a good reference manual into the future, as I sit down for some fancy picture drawing, also known as visual modeling. This is that book. I would definitely recommend this book to anyone looking for a well-written, easy to follow and understand, concise UML 2.0 reference manual. If you're a career designer, note that this book does not describe in full detail, the complete syntax of UML 2.0. That said, if you're drawing fancy pictures using syntax not described in Fast Track UML 2.0, then perhaps that's a sign that you're models are too detailed. If you're brand new to the study of OOAD looking to develop these skills, this book alone probably isn't what you're after, though it would still serve well as a supplement to another material geared towards teaching OOAD. As a bonus, the book is priced well. Discuss book in the Saloon — More info at Amazon.com
Software Architecture Design Patterns in Java by Partha Kuchana
AUERBACH 1 edition April 2004 416 pages	Reviewed by Lasse Koskela, August 2004 (9 of 10) Design patterns used to be the hottest topic around a couple of years ago. One of the side-effects was the "Applied Java Patterns" book which I very much liked and used to recommend to anyone looking for a "GoF" replacement using Java for code examples. Not anymore. From now on, I'm recommending Kuchana's "Software Architecture Design Patterns in Java". Why am I so pleased with this book? What makes it any different than other design pattern books? Well, first of all the volume is huge. Kuchana's book covers all the original Gang of Four patterns plus another 20 or so patterns, including a couple of multithreading related patterns. Second, the text itself is very readable and doesn't cling too much on fancy words. The explanations are concise and to the point. Further kudos goes to dealing with such frequently asked questions like the difference between Factory Method and Abstract Factory. To list some things I didn't like about this book, I have to say that having exercises without sample answers in the back was a tiny disappointment and I would've preferred a bit more condensed font for the code listings. That's about it. All in all, a very good choice for filling the gaping design patterns encyclopedia slot in your bookshelf. Highly recommended. Discuss book in the Saloon — More info at Amazon.com
Fearless Change - Patterns for Introducing New Ideas by Mary Lynn Manns, Linda Rising
Addison-Wesley 1 edition September 2004 273 pages	Reviewed by Ilja Preuss, October 2004 (10 of 10) Did you ever struggle to introduce a new idea at your workplace that would make everyone's life easier? Did you ever wonder how some people actually manage to introduce changes? Then this book is for you. "Fearless Change" starts by explaining why change is so hard and what we typically miss when we approach change, followed by an excellent introduction to the broad concept of patterns in general. The "patterns for introducing new ideas" are then introduced in a sequence of chapters, each dedicated to a specific phase of the change process - from testing the waters, over getting the first people on board, to convincing the masses and finally keeping the implemented change alive. One chapter solely discusses how to deal with resistance. Four experience reports (one about the introduction of the J2EE patterns) then show how the patterns have been successfully used in concert. The third part of the book contains an alphabetical catalog, describing every aforementioned pattern in detail. The whole book is quite entertaining to read, every chapter being to the point and at the same time filled with clever quotations and examples from the trenches. On each page you sense it's not only the experience of the two authors that is to your disposal, but also that of dozens of people they talked with during the years. If you want to have an impact on how things are done at your workplace, you should put this book at the top of your reading list. Discuss book in the Saloon — More info at Amazon.com
Refactoring To Patterns by Joshua Kerievsky
Addison-Wesley Professional 1 edition August 2004 400 pages	Reviewed by Corey McGlone, October 2004 (9 of 10) A high quality reference for those that want to gain some direction to their refactoring. That's what Joshua Kerievsky has managed to create with this book. This book assumes that you already know about refactoring and even states clearly that this book is best read with Martin Fowler's "Refactoring" as a reference. With that prerequisite in mind, this text does an excellent job of introducing the process of using refactorings to fix code problems by introducing patterns into your design. Some of the strongest points include: editing, organization, and clarity. My hat goes off to the editor(s) of this book as I found very few errors even though this book contains a lot of "real world" code. Organizationally, this book does an excellent job of making itself useful as a "read-through" book for those that want to immerse themselves in the topic and as a reference book that can sit on your shelf until you need it. One word of caution about this book is that it originally started as a paper and grew from there. Especially throughout the first few chapters of the book, this is very evident. Constant references to works done by other authors and numerous footnotes can, at times, become a bit distracting from the overall message. Overall, this is an excellent book and, if you're into extreme programming and refactoring, it's one that you're going to want to have on your shelf. Discuss book in the Saloon — More info at Amazon.com
Java Testing Patterns by Jon Thomas, Matthew Young
Wiley 1 edition October 2004 424 pages	Reviewed by Jeanne Boyarsky, October 2004 (4 of 10) "Java Testing Patterns" is one of those books where it appears nobody edited. Java class/method names and acronyms are used in lower/upper case interchangeably. Writing class names in all lowercase in a Java book doesn't inspire much confidence in the accuracy of the rest of the book. There are many typos and inconsistencies that make it hard to read. The formatting is also very poor. The code looks good in Eclipse, but not in the book. Lines wrap without indentation. Similarly, UML diagrams are randomly split into pages. They are supposed to be on the web, but they aren't yet. The intro states a target audience of "software engineers, engineering managers and software testers." This book is heavily reliant on reading code. After the first few chapters, I don't think managers or testers would benefit. Speaking of code, I think the code is too verbose and complicated -- especially for a book. A few times, a simple JavaBean's source takes up one to two pages. One DAO takes up 12 pages. There is a test method with 16 branches. These examples make understanding quite difficult. Now as for what the book does well. There are five good chapters on patterns. However, two are in essence the Factory and State patterns. The appendices are very good too. I wouldn't buy a book for three chapters and some appendices. Other books cover the material better. I would not recommend this book in its current edition. Discuss book in the Saloon — More info at Amazon.com
Head First Design Patterns by Elisabeth A. Freeman, Eric Freeman, Bert Bates, Kathy Sierra
O'Reilly 1 edition October 2004 676 pages	Reviewed by David O'Meara, November 2004 (10 of 10) Make sure you read the introduction so that you know what you're getting into, and to realize you're getting into something great. Rather than being a group of books with little real point of difference, the Head First principles - outlined in the introduction - are geared towards presenting real problems and real solutions with real learning. But we're supposed to be talking about Head First Design Patterns. The list of patterns presented is small compared to other books, but this works well since the coverage is more about learning the basic patterns well with a solid understanding. Also of great value is the way each pattern is taught by presenting common problems with the obvious, but wrong, solutions and then leading you out of the hole you dug and highlighting the important steps towards a better and more maintainable solution. I was particularly impressed how the presentation of each pattern was built on solid Object Oriented concepts. But rather than assuming you know these advanced concepts, they are integrated into the learning exercise and presented as a cohesive bundle. The book is also structured so it refers back to and reinforces both the pattern and OO lessons as you progress. It's hard to find real fault with the book. At times it jumps between topics, is repetitive and a bit irreverent, but this is all part of the formula and exactly what is promised. Beginner or experienced, you better be careful or you might learn something. Discuss book in the Saloon — More info at Amazon.com
Prefactoring by Ken Pugh
O'Reilly 1 edition September 2005 238 pages	Reviewed by Jeanne Boyarsky, December 2005 (8 of 10) The term "prefactoring" is supposed to mean using things you learn from your own experience or the experience of others to improve new programs. The book "Prefactoring" revolves around approximately 70 requirements and design guidelines. The stated audience is anyone who understands the basic concepts of OO. It is good for a beginner who has read some or a practicing developer who wants a reminder of best practices. Most of the book follows the development of a fictional system. The guidelines are sprinkled throughout as appropriate. The author is realistic in noting that many exceptions to the guidelines exist. A few are illustrated within the context of the fictional system. However, I found the user of some guidelines left much to be inferred by the reader. The guidelines focus on abstraction, separation of concerns and readability. An appendix cross references them well. The fictional customer was realistic in demands, which was nice to see in a book. Overall, the book read well, was factually accurate and provided a good walkthrough of the thought process in a sample design. But on the book's focus of guidelines, it left me wanting more depth. Discuss book in the Saloon — More info at Amazon.com
Pattern Languages of Program Design 5 by Dragos Manolescu, Markus Voelter, James Noble
Addison-Wesley Professional 1 edition May 2006 624 pages	Reviewed by Jeanne Boyarsky, May 2006 (7 of 10) "Pattern Languages of Program Design 5" is the latest in a series output by the PLoP (pattern languages of programming) conferences. A pattern language is a group of higher order design patterns that go together to form a vocabulary for a specific problem. Each chapter stands on its own and is written by different people. This makes the format all over the place - each chapter is somewhat different. Some of the content is fairly specialized. There are chapters on real time systems, radio and pattern writing. While all of these are fascinating, they are unlikely to appeal to the same group of practicing developers. At times, the book feels academic. It is probably supposed to as it is on introducing new patterns to the world. I felt there was a strong emphasis on contributing to PLoP and writing new patterns. That said, each chapter was very good on its own. The authors were all interesting and explained the topic clearly. There were good examples and the quality was high. I recommend this book if interested in PLoP or pattern writing in general. If you've read #4 in the series, you will definitely find this one enjoyable. If not, I would recommend starting with #1 in the series. There are some backward references to earlier books, so it would be easier to follow. Discuss book in the Saloon — More info at Amazon.com
Design Patterns in Java by William C Wake
Addison-Wesley Professional second edition April 2006 480 pages	Reviewed by Frank Carver, May 2006 (9 of 10) It's hard to review this book without mentioning "Design Patterns" by Gamma, Helm, Johnson and Vlissides (known as "Gang of Four", or "GoF"). Both start with a general intrduction, describe the same 23 patterns, and even have an index of patterns inside the front cover.. That said, it's the differences which matter. . GoF chose mainly UML and C++ to describe the patterns in detail. This book considers how these patterns can be used in Java. That in itself is significant (at least if you use Java), but there is also a strong difference in style between the two books.. GoF is dry and academic, sometimes requiring a lot of study to understand and apply abstract pattern descriptions. This book, on the other hand, is much more lively - full of worked examples, self-test problems and puzzles, all set in the context of a fictional firework manufacturer. This makes it a much more enjoyable read. And if you get stuck, the solutions are all in the back.. However, this easy-reading, approach has a negative side. The patterns are so comfortable and copyable that subtlety can be missed. Take Flyweight, for example. Admittedly this is one of the rarer patterns in the wild, but in this book it seemed more like a recipe for one particular usage than an exploration of possibilities.. In summary, GoF is a crusty classic worthy of anyone's bookshelf, but this book provides a useful and practical introductory step for anyone working with Java. Discuss book in the Saloon — More info at Amazon.com
Clean Code - A Handbook of Agile Software Craftmanship by Robert C. Martin
Prentice Hall edition 2009 430 pages	Reviewed by Janeice DelVecchio, April 2010 (8 of 10) Robert Martin's Clean Code was an awesome read. This book illustrated the major points of writing readable and maintainable code. There were lots of code samples, and examples of how to make the code tell its own "story" and become readable to any programmer who comes along. It would be an appropriate read for someone at at least an intermediate level of understanding of programming. All the code examples are written in Java. The entire last chapter was a summary of all the "code smells" that he had discussed throughout the book. This could make the book useful on a longer term basis as a reference book. Although the book did light the desire in me to go and find programs to refactor, I felt the book as a whole dropped the ball a little when it came to depth. Each relatively short chapter (there are 16 plus the section with the rehash of code smells) could have been fleshed out with more substance -- especially the chapters about unit testing, data structures, and error handling, and the sections that discussed the costs of maintaining dirty code. There is an appendix adding to the concurrency chapter. I thought this might have sat better in the chapter itself and the other chapters extended. Overall a great read, and a good foundation to build on when the goal is readable code. Disclaimer: I received this book from the publisher in exchange for writing this review. Discuss book in the Saloon — More info at Amazon.com
Building Applications in the Cloud: Concepts, Patterns, and Projects by Christopher Moyer
Addison-Wesley Professional 1 edition April 2011 400 pages	Reviewed by Peter Johnson, June 2011 (6 of 10) Here is a quote from the preface: "Threading typically relies on a scheduler built into the language". If the author was writing about Windows 3.0 I would probably agree. But threading has been handled in the OS and hardware for ages. The book relies entirely on Python, and perhaps the author's statement is true for Python; but the author's technical inaccuracies lead me to be skeptical about his other claims. This main content of the book is split up into three parts. The first part discusses the boto library, which is a Pyhton layer on top of the Amazon API that the author wrote. This is the first strike against the book - I tend to dislike this type of bait-and-switch style. Second, the book focuses almost entirely on Amazon's cloud products - the author does mention other clouds briefly but 99% of the examples are Amazon specific, using boto of course. The second part describes the various pattern, all of which are very obvious to anyone who has done any enterprise-level application deployment. The third part goes into detail on a blog application, one written in boto, the other written using Marajo for Google's AppEngine. The problem with this section, and with the code examples for the prior section is that the application of the pattern(s) is never clear. The author spends a lot of time explaining the application and how it works, but very little, if any, time explaining how the application illustrates the pattern(s). I came away feeling as if the author meant to write a book about boto, realized it wouldn't sell, so converted it into a book on cloud application patterns to give the book broader appeal. I don't think he succeeded. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Essential Skills for the Agile Developer: A Guide to Better Programming and Design by Alan Shalloway, Scott Bain, Ken Pugh, Amir Kolsky
Addison-Wesley edition 2011 234 pages	Reviewed by Matthew Brown, October 2011 (9 of 10) This book is aimed at developers beginning to work in an agile way, and lays out a set of principles and practices for design and programming that will help them succeed. Although really, most of them are more generally applicable than that: this is all about "good design", with an emphasis producing code that is easy to change. As a developer with relatively little experience of agile methods, I was a bit surprised how much of this was relevant to my own work. The main difference that the agile focus seems to make is when to do things, not how. Key subjects covered include: programming by intention, separating use from construction, and acceptance-test driven development. Encapsulation is a theme running through the book, and they take a wide view of what this actually means, interpreting established design patterns as encapsulations of some particular concept so that it is easier to adapt. The book isn't tightly coupled to a particular programming language, although it's usually considering an object-oriented approach. Examples are generally Java/C#, with occasional comments about other languages, but most of the time it's talking about more general principles. The examples are clear and easy to understand. It's certainly readable and useful. My one real criticism is that it's occasionally a bit repetitive. Sometimes that's simply a natural result of way the different concepts under discussion interact, but there are times it seems unnecessary (one small example: a comment about the origin of the "extends" keyword in Java appears twice). Perhaps that's a danger in a multi-authored book? But that's a small fault in an otherwise excellent book. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley edition 2011 234 pages	Reviewed by Mohamed Sanaulla, February 2012 (9 of 10) This book does justice to its title and subtitle- it clearly tells you the basic design principles to write good code which is easy to read, debug and extend. At first glance the title may seem misleading as it uses the word "Agile Developer" but there isn't much specific to agile in the book, though familiarity with terms like Scrum or Kanaban or TDD would be an added advantage. Salient features of the book: - Emphasis is on the basic design principles like Cohesion, Coupling, Encapsulation, Redundancy, Coding to Interface. These are further built upon to introduce/redefine the ideas. - Covers each concept in depth and with the aid of repetition of concepts helps in grooving them into the developers mind. - References to other Books which cover a referred concept in depth which can help in in-depth study. - Appendices with extra information to aid in better understanding. - Concepts explained with simple examples to drive home the concept. Few gotchas: - People not familiar with coding/new to it might not find the book very appealing, hence I would recommend the book to someone who has worked on a large codebase and may be some legacy code (not dating back to 80s). - Suggestion would be to read the Appendix first, might help for people who are not familiar with UML notation. Basic design principles are also explained there. - Familiarity with GoF design patterns is a PLUS, as these have been referred all over the book. - One can visit the references provided in each chapter to read up more. So, if you are thinking of picking this book- I would say go ahead, you can always re-read it to refresh the concepts. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley edition 2011 234 pages	Reviewed by Ankit Garg, February 2012 (8 of 10) This is a very good book for anyone who has to makes design decisions in development. It describes different approaches to design and development and the pros and cons of each approach. For example the book tells you where to use inheritance and where to use delegation. Its not a design patterns book, rather it describes different programming methodologies and techniques which are required in Agile development. The book covers a wide variety of topics which will increase your knowledge by many folds. If you have been in development for some time, you might be familiar with some topics covered in the book as you might already be following them. The techniques described in the book are extremely practical and useful. The book is easy to follow on most places. There are however some chapters which are a little confusing. Specifically the examples in the Needs vs Capabilities interface are not easy to follow and relate to in real life scenario. It also took me some time to figure out what Shalloway's Law described in a chapter meant. Other than that all other chapters are easy to understand with the examples and diagrams. The Appendixes are also useful for beginners. Overall this is a very good book and is a very good read for any developer who has some experience in development. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Element Design Patterns by Jason mcSmith
Addison Wesley edition 2012 323 pages	Reviewed by Wendy Gibbons, May 2012 (1 of 10) I am not sure who this book is aimed at. The introduction feels like it is aimed at experienced developers, yet the actual body of the book states facts that are so basic anybody who has done OO for more than 6 months should already know it. The introduction uses the decorator pattern as example for some of his concepts, it presumes you already know what the decorator pattern is. Then he moves onto describing the Elemental Design Patterns, one of these is "create object", you may think I am talking about a new variant of the factory pattern but nope he means [code]new object()[/code] How about the "Retrieve" pattern, hopefully you have set your ideas low enough now to realise this is get something from another class. Then he moves onto using his elemental design patterns into "intermediate design patterns" one of these is the "Fulfill Method" this is writing the method details for an interface method. I have to confess I gave up at this point, as everything else seemed to be appendices. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Addison Wesley edition 2012 323 pages	Reviewed by Mohamed Sanaulla, June 2012 (6 of 10) The Elemental Design Patterns are a result of the System for Pattern Query and Recognition(SPQR) project. Having roots in a research project the book tends to have a research thesis like attention to detail and this kind of puts off the developer who looks to gain quick knowledge or a a quick benefit out of the reading. If you want to learn design patterns, then this is NOT the book for you. This book: - is all about decomposing a pattern into its components until it gets to basic part. - reading about the basic aspects of OO like Objects, Inheritance, Abstractions. - contains few examples of using the basic components to derive patterns. The bottom line is- You get to learn what it takes to derive a pattern and also understand the components of existing patterns. Some things I against the book: - Too much of theory to read, the quantity of text might be because the author has tried to explain the concepts in detail. - Might be irrelevant for a seasoned developer. - Not really different from the book which explains the design patterns. - PIN diagrams make things unnecessarily complicated. - Basic concepts have been presented with some complicated names. - Code Examples are predominantly in C++ with some samples in Java, Objective C, Python. You would read this book: - If you want to understand everything below a pattern. Something like applicable to a research student in patterns. I wouldn't recommend this book to any developer interested to learn about the patterns. They might be misguided by the title, but for sure its not something you would find useful for your day to day coding work. Lot of Design Patterns books which cover these patterns do explain how they are derived and people pursuing learning of patterns should have already been familiar with basic OO Concepts. I would give 6 out of 10 for its research content, new techniques like PIN diagram and effort to automate the identification of patterns in the codebase using the concepts of EDPs explained in the book. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Java Application Architecture: Modularity Patterns with Examples Using OSGi by Kirk Knoernschild
Prentice Hall 1 edition March 15, 2012 384 pages	Reviewed by Amit Ramchandra Ghorpade, December 2012 (7 of 10) When we speak of architecture of Java applications, be it desktop or web, we start with the high level specifications, impart service level or functional patterns and move on to the UMLs. I have rarely seen any design worrying about modules in the system since we take for granted that our design decouples them implicitly. This book was my first encounter with modules with Java and I was surprised to read the importance of modularity in Java applications. The first section introduces to the modularity concepts. If you are already familiar with them, you can directly head to patterns in section 2 after taking a brief look at chapter 7. The section 2 on patterns is divided into types of patterns making it easy for the reader to focus on what exactly he needs. Most of the base patterns stuff I believe is imparted by the design itself, even if its not given special treatment. Module facade was a totally new thing for me, I always thought facade is meant for some service. The next section talks of OSGi, which was interesting again because my view of OSGi was that its more into services. To put it together it is a good book, with real world examples for novice through intermediate readers and a handy reference for experts. One go-through of the book will certainly bring up better designs and add another facet to the application architecture. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Prentice Hall 1 edition March 15, 2012 384 pages	Reviewed by Mohamed Sanaulla, January 2013 (8 of 10) This book consists of two parts: 1. Deals with the basic concepts related to modularity 2. Patterns dealing with modularity. The book deals at the architecture level and the patterns described therein are more suited to building a good architecture and also a great class design. The first part deals with building the base for understanding the patterns described in the later part of the book. It doesnt require any prior experience in OSGi and there are around 2 chapters which are very specific to OSGi. The patterns are well described and each has a description, consequences, sample implementation of the pattern. The content is quite easy to understand and all the concepts are very well depcited using informative images. I would not recommend this book for someone not well versed with basic OOP concepts, code level design patterns. If you have quite a bit of experience and are in a mid-senior level developer then you can really appreciate the content of the book. And its not necessary for you to read through all the patterns in depth, but its useful if you are aware of what patterns are available so that you can refer to it when ever required. In short this book tries to bridge the gap between architectural design and the class level design in Java based applications. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
SOFTWARE DESIGN PRINCIPLES by Ludwin Barbin
Ludwin Barbin edition August 2013 72 pages	Reviewed by Jeanne Boyarsky, August 2013 (6 of 10) "Software Design Principles" is $4. Amazon claims it is 72 pages. The pdf is 50 pages and minus the front/back matter, there are a little under 40 pages of content. Which is fine for a $4 e-book, but quite misleading. It also irks me that the title of the book is in all capitals on Amazon as that feels like shouting on the internet. But on to the actual content: Some principles are described at length. Others are barely mentioned with only a sentence or two of description. Continuous integration has one paragraph (5 sentences), but it feels like the principle is barely touched on. I really liked the "synthesis" table which shows graphically how principles go together. And the descriptions are fine. Some of them are quite thorough in fact. My biggest problem with the book is that I feel like it covers too much for a 40 page book. In that way, it servers more as "here is an overview of some topics you might want to read more about elsewhere." The author says that he inserts his own experiences throughout the book. I only counted 4 such instances. He also says the book can serve as both a tutorial and a reference. I agree on the reference part. I agree that it can be used as "cheat sheet." I disagree that it is comprehensive enough to cover "even the edge concepts." I also think the target audience is too broad. A software architect should know this material by now. Although I suppose it could serve as a review. And I think a junior developer would require more elaboration. That said, the book only costs 4 bucks. It's worth buying just as an outline or a list of things to learn more about after you have gotten the overview. I think I was most bothered by the implication that the book was longer. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Writers' Workshops & the Work of Making Things: Patterns, Poetry... by Richard Gabriel
Pearson Education 1 edition June 2002 288 pages	Reviewed by Kyle Brown, July 2002 (9 of 10) Every fall, just after school starts, some of the finest minds in object-oriented programming depart for an extraordinary conference in an improbable location. Held at a turn of the century mansion hidden among the corn fields of central Illinois, the PLoP (Pattern Languages of Programs) conference is one of those rare, magical events where everything you know about the way the software world works is turned on its head. Instead of "acolytes" gathering around the feet of the "master" to hear the same talk that he gives at every other conference, experienced folks like Richard Gabriel, Ralph Johnson, Kent Beck and Ward Cunningham sit and give personalized advice about how the patterns and pattern languages written by first-time authors can be improved and strengthened. It's a place where you might find out one of your dinner companions has written four books on OO design and speaks at conferences twelve times a year, while the other is a new graduate student just getting started in the field. How does this occur? And why do people keep coming back year after year? The key is in the primary innovation of this conference -- bringing the notion of an Author's Workshop to computer science. Richard Gabriel is the person who introduced that idea to the computer science community, and he writes lucidly and joyfully about the wonder and the terror of Author's workshops in this delightfully agreeable little book. In this volume, Richard describes how the Author's workshop came out of the creative writing and poetry community, and provides a roadmap for carrying out a writer's workshop. He describes the benefits of the process, and gives sage advice to the participants in such workshops. He draws his stories and examples from his varied experiences in workshops in both communities (software and literature) and explains why such an unlikely way of doing things has come to be so valued and cherished by the software patterns community. So, if you've wondered why people in the software patterns community are so set on the way they run their conferences, read this book and you'll understand why. But that's not the only value; reading this book can give you insight into how to improve your own writing in any genre, and how to marshall the resources of your communities to improve the quality of your work. I'm hooked on this process, and I'm delighted that I finally have something to refer people to so that I can share some of the magic of this unconventional way of teaching, and learning. Discuss book in the Saloon — More info at Amazon.com
Patterns for Time-Triggered Embedded Systems by Michael J. Pont
Addison-Wesley Professional 1 edition July 2001 1024 pages	Reviewed by John Volkar, December 2001 (10 of 10) Not your typically software patterns book. Real engineering, hardware and software making stuff happen! Yeah! Probably the best example that I've ever seen of how patterns should be described and discussed, clear, concise, and with sufficient background to make each pattern feel meaningful and complete. While this book deals specifically with the 8051 family of microcontrollers, almost all of the patterns given are generally applicable to any microcontroller family. Even if you're just a software engineer, and even if you don't do embedded work, at least half of this book contains information that will pique your interest, and cause you to rethink some of your assumptions. Pretend that you have to write an embedded program that responds in real time and has a bounded response window. Now you have the choice of a preemptive or cooperative scheduler. (For all you nonhardware folks: A scheduler is a microoperating system that you either buy of build yourself for your microcontroller.) I'd say most folks would choose the preemptive scheduler. Needless to say, the patterns in this book give clear guidelines as to which to choose and when. Furthermore, they illustrate that for the most reliable (most predicable) operation, a cooperative scheduler is probably a better choice. Now think about some business systems architectures, response times, latency, liveness, robustness, the discussions on embedded schedulers have relevancy! The world needs more books of this caliber and utility. If you're even remotely interested in embedded systems, GET THIS BOOK! Discuss book in the Saloon — More info at Amazon.com
Core J2EE Patterns: Best Practices and Design Strategies by Deepak Alur, John Crupi, Dan Malks, Deepak Alur, John Crupi, Dan Malks
Prentice Hall PTR second edition May 2003 528 pages	Reviewed by Thomas Paul, August 2003 (9 of 10) There are two obvious changes between this second edition and the first edition of this book. First, some new patterns have been added mostly dealing with web services. Second, the book has been released as a hard cover book, presumably because the publisher expects this to last on your shelf as long as the original "Design Pattern" book. The new patterns dealing with web services are a welcome addition to the book although anyone who is interested in this subject will probably want more detail such as found in Paul Monday's book. Part 1 is an introduction to design patterns and the J2EE platform followed by a catalog of design considerations, bad practices and refactorings. Part 2 is the collection of design patterns and strategies. Each pattern is described in a format which will remind you of the GoF book. Since this has become the standard ormat for presenting design patterns this should not be a surprise. The patterns are well thought out, explained clearly, and demonstrated with some good code samples. If you have the first edition you will be very impressed with the improvements made in this new edition. It appears that virtually every pattern has been reworked to make the pattern easier to understand and use. This is the book that every J2EE architect and programmer should have on their desk. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful. Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR 1 edition June 2001 496 pages	Reviewed by Thomas Paul, November 2001 (10 of 10) Not another line of code for Servlets, JSPs, or EJBs should be written by anyone who hasn't read this book and understood the concepts explained. This book is about best practices in designing and coding J2EE applications. The lessons explained here were developed by the Sun Java Center based on their work in the field. As they developed applications for clients they noticed that the same problems occurred over and over again. This book documents the standard solutions to solve these problems that were built as a catalog of design patterns and best practices. Part 1 is an introduction to design patterns and the J2EE platform. Part 2 is a catalog of bad practices (the authors describe these as, "less than optimal ways to solve problems"), and refactorings (ways to correct these problems). Developers working with poorly designed J2EE applications will find this section especially helpful. In Part 3, fifteen separate design patterns and strategies are explained. Each pattern is described in detail with the motivation for using the pattern and the design goals to be achieved. UML class and sequence diagrams are included along with detailed code examples that serve to further clarify the pattern. These patterns aren't theoretical constructs but rather are practical strategies that can be applied to real world applications. Using the strategies in this book will make you more productive and your code easier to understand and maintain. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful. Discuss book in the Saloon — More info at Amazon.com
J2EE Design Patterns Applied by Matjaz Juric, Nadia Nashi, Craig Berry, Meeraj Kunnumpurath, John Carnell, Sasha Romanosky
Peer Information 1 edition June 2002 450 pages	Reviewed by John Wetherbie, December 2002 (8 of 10) This book presents J2EE design patterns from Sun and TheServerSide.com for developers and architects creating J2EE-based systems. I really like the way the patterns are presented with a fair amount of code to flesh out implementations (or "instances") of each pattern. The patterns are grouped by tier/usage which is helpful if you are looking for patterns in a particular area. The discussions about why you would want to use a specific pattern and items to keep in mind when using it are very nice. My only complaint, and it is a mild one, is that each of the chapters that deal with a tier or aspect could be expanded into a separate book. (Hint to publisher... ;-)) This is a very good introduction to J2EE design patterns. If you want help in designing your J2EE systems in regards to security, scalability, and modularity this book will help you achieve your goals. Discuss book in the Saloon — More info at Amazon.com
Patterns of Enterprise Application Architecture by Martin Fowler, et al
Addison-Wesley Professional 1 edition November 2002 560 pages	Reviewed by Junilu Lacar, March 2003 (10 of 10) Simply put, you can't go wrong with a Martin Fowler book and this one is no exception. If you climbed the mountain to get advice from the IT guru at the top, he'll probably quote from this book. Born on the web and rarefied by reviews and discussions with Fowler's colleagues and peers, including JavaRanch bartender Kyle Brown, this book is full of ideas that will help you make decisions related to enterprise applications architecture. Writing in the same easy-to-read style as his past works, Fowler presents over fifty patterns that are mainly focused on layered architectures. And while Fowler readily admits that none of the ideas are new, developers, experienced or otherwise, will nonetheless benefit from the collective wisdom and experience of Fowler and all who contributed to the book. To get the most out of this book, be sure to read the introductory chapters and understand the author's intent. There are many code examples, mostly in Java with a few in C#. I doubt though that you can use the code without some sort of tweaking; they are all meant to show the core of the pattern. Ultimately, you have the best understanding of your requirements and you have to make the decisions that affect your application's architecture. To paraphrase Fowler, don't use the examples as glorified macros but as a way to stimulate your own thinking. And believe me, this book has more than enough to get you thinking. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley Professional 1 edition November 2002 560 pages	Reviewed by David O'Meara, March 2003 (9 of 10) It's a patterns book, it's by Martin Fowler, and it's good. But how good is it? It is actually two books in one. This is discussed in the book, but the second half is a list of patterns including the information required to make them useful. Reasonably standard, except that the patterns are presented in a language neutral manner that gives Java developers a view into the .Net world and vice versa. The best part is still the first section. There is a general discussion on enterprise applications including common problems and ways to solve them depending on the way it shows up in your application. Not all of it will be new to everyone, but I'd challenge anyone not to learn anything. Even if you don't agree with all the solutions posed, it has very concise coverage of the problems. There appeared to be the assumption of a respectable level of experience in the reader, so the book may not be useful to programmers with less than 3-5 years under their belts. This isn't necessarily a down side, but it should be considered if you're considering purchasing the book. Now a small complaint. Although the first section was great, it discussed the patterns from the section in too much detail. There were some patterns I wasn't familiar with and some that I knew by different names, and it made some sections confusing. Still well worth a place on the shelf. Discuss book in the Saloon — More info at Amazon.com
Java Enterprise Best Practices by Jason Hunter, Bret McLaughlin, Hans Bergsten, et al
O'Reilly 1 edition December 2002 288 pages	Reviewed by Ajith Kallambella, March 2003 (8 of 10) An appetizer that leaves you hungry for more. Patterns and best practices have been around for a long time. They solve problem domains not directly addressed by the language itself ie., repeatable solutions to family of application development issues -- be it architecture, deployment or testing. For a complex platform like J2EE, use of best practices can make or break a project. Just what the doctor ordered - Java Enterprise Best Practices is a collection nuggets of wisdoms. It is a compendium of idioms classified based on various enterprise Java areas written the most acclaimed authors in the field (Jason Hunter, Bret McLaughlin, Hans Bergsten et al). Ranging from most widely used EJBs to the latest additions such as JMX and JSTL, each chapter presents the reader with most widely accepted norms of using technologies such as - EJB, Servlets, JDBC, XML, RMI, JMX, Internationalization, JSP, JavaMail. Chapters on XML and RMI are the best of the lot. I was surprised to note the omission of JMS, given that its popularity when compared with other things such as JMX or JSTL. The last chapter on performance tuning lacks depth and reads more like hastily scribbled notes. Can best practices be argued? Absolutely! The first chapter of the book says just that. It is important to bear that in mind while you read through the chapters. While a seasoned J2EE developer idioms may find a few things trivial, it is quite a good reference to keep handy if you are developing real-life applications. Discuss book in the Saloon — More info at Amazon.com
Web Services Patterns: Java Edition by Paul B. Monday
Apress 1 edition April 2003 352 pages	Reviewed by Thomas Paul, August 2003 (8 of 10) Now that we have read all the books on the basics of web services and have a good understanding of how they are supposed to work it is time to get down to actually trying to create some decent designs for our web services applications. That is where this book fits in. The book shows how to apply design patterns to a web service architecture in order to solve common design problems. If you are designing a web service architecture you will want to read this book before drawing another UML diagram. The book starts out by looking at the design patterns used in web services itself. This part of the book was interesting but not overly useful. The next part, making up most of the book, covers design patterns that you are likely to need in developing web applications. This part of the book is excellent. Each pattern is discussed in detail and then demonstrated in a case study that is developed throughout the book. The book covers twenty different patterns so there is bound to be one that is applicable to your application. The book contains only snippets of code from the case study so you will need to download the code in order to get the full value of the case study. The reader of this book should be comfortable with web services and design patterns in general and be ready for an in-depth discussion of web services architecture. Discuss book in the Saloon — More info at Amazon.com
Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions by Gregor Hohpe, Bobby Woolf
Addison-Wesley Professional 1 edition October 2003 736 pages	Reviewed by Lasse Koskela, December 2003 (10 of 10) Enterprise Integration Patterns is part of Addison-Wesley's new Martin Fowler Signature Series, which Fowler's Patterns of Enterprise Application Architecture (PoEAA) is also a part of. I was very satisfied with PoEAA and the same can be said about Enterprise Integration Patterns. It has the potential to become a classic. The authors' writing style is a pleasure to read -- no ambiguous statements, no unnecessary babbling. The book is structured to suit both cover-to-cover reading and a "dive-in" approach for situations where you're looking for a solution to a particular problem. After an introduction to the field of enterprise integration, and a discussion of why the book concentrates on the messaging integration style in particular, the reader is given a hierarchical catalog of patterns revolving around a small set of "core" patterns. The book's coverage is in my opinion very well scoped. I must also praise the look of the book; besides the layout being familiar from prior works and the proven pattern catalog structuring, the authors have used graphics very efficiently. Not only the authors define a vocabulary for integration patterns, but they have also come up with an expressive visual language for illustrating the patterns using simple notations that can be easily drawn without CASE tools. I found only two downsides for this book. First, the title can be slightly misleading as the book focuses on messaging as an integration style and only briefly mentions alternatives such as RPC, file transfer, and shared databases. However, I don't know a single person who doesn't read the back cover before buying a book, so I wouldn't count this as a big issue. Furthermore, the reason for focusing on messaging is thoroughly argued in the book. The second downside is the code examples, which are presented using varying languages and products and seem somehow disconnected from the text. In summary, Enterprise Integration Patterns is a great book. It's worth reading and re-reading if you're working with systems integration projects or writing integration software yourself. Yet another book that makes me think, "I wish I had it back then..." Discuss book in the Saloon — More info at Amazon.com
JasperReports 3.6 Development Cookbook by Bilal Siddiqui
Packt Publishing 1 edition July 1, 2010 396 pages	Reviewed by Ankit Garg, September 2010 (7 of 10) The book can be used by beginners and experienced people in JasperReports. This book teaches you how to develop reports using iReports, the GUI report designer. The book is full of snapshots which makes learning very easy. There were some errors in some of the snapshots, like on page 200 the values of static text components is not consistent which might be confusing. But overall the snapshots are pretty good. The first three chapters are very basic, and they are only useful for beginners. If you are familiar with JasperReports, you'll already know things covered in these chapters. From the fourth chapter the book moves to advanced recipes. Beginners might face some difficulties understanding some of these recipes. There is a lot to learn for people familiar with JasperReports in these chapters. The last chapter covers generating reports from Java code. This chapter covers topics from compiling a report from java code to exporting it to Excel, Pdf or printing it. It also covers how to generate reports from a web application. This topic has some technical errors (not related to JasperReports) like the response content type is not set through a page directive, there should be no HTML tags in the generated content as its a PDF response and the report is generated through a JSP page using scriptlets instead of a Servlet. The JasperReport code is correct though so this is not a big issue. An additional chapter can be downloaded from the publishers site which is a little weird. Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch. Discuss book in the Saloon — More info at Amazon.com
Building Web Applications with UML by Jim Conallen
Addison-Wesley Longman 1 edition December 1999 320 pages	Reviewed by Carl Trusiak, April 2001 (7 of 10) If you are new to UML and are looking for a good book to learn with, then this book isn't for you. On the other hand, if you are experienced with UML modeling, you can save yourself some time by skipping the first five chapters. The real meat of the book gets started in chapter six. From there, it is extremely packed with information to help you model a website. The biggest disappointment for me was the minimal number of examples in Java, Servlets and JSP. There are a few. However, the complete Model Example is in Active Server Pages. I'd really love to see an erratum for the book with the example done using Java Technology. If you need to learn a standard way for your organization to model dynamic web pages, this book is a must. Discuss book in the Saloon — More info at Amazon.com
Java Design: Objects, UML, and Process by Kirk Knoernschild
Pearson Education 1 edition December 2001 257 pages	Reviewed by Junilu Lacar, May 2002 (4 of 10) At first glance, this book looks promising. It has all the right stuff listed in the table of contents: general principles of object-oriented design, patterns, refactoring, incremental development, UML, RUP, and even XP. Don't be fooled though because the actual discussion is introductory at best with an almost incidental treatment of Java and how it ties in with the UML, modeling, designing, and creating what the author likes to call a "resilient architecture." While the book discusses a lot of things that you should know about OO design, UML and iterative development processes, it lacks the focus and depth needed for it to be truly useful. The discussion on UML and design revolves mainly around two use cases and there are very few other examples. Most of the time the author is introducing a new concept and constantly referring to other parts of the book where it will be or has been discussed in detail. However, when I got to the end of the book I was still expecting more detailed discussions and had to go back to see what I missed. You'll probably get more bang for your buck with Martin Fowler's books on UML and refactoring and Craig Larman's book on UML, patterns and the Unified Process. These books are filled with the examples that "Java Design" sorely lacks. For OO design principles, read the articles by Bob Martin published on http://www.objectmentor.com. Discuss book in the Saloon — More info at Amazon.com
Agile Software Development: Principles, Patterns, and Practices by Robert C. Martin with contributions by James W. Newkirk and Robert S. Koss
Prentice Hall 1 edition October 2002 529 pages	Reviewed by John Wetherbie, January 2003 (9 of 10) Agile Software Development is a great Object-Oriented Design book that presents it's subject in the context of Agile Development. The book delivers solid design and programming advice in a very "light" style. Not light in that it avoids technical detail! No, Bob seems to have taken the principles of agile development and applied them to the art of technical book writing. The book is divided into six sections and has four appendices. There are many UML diagrams and lots of code examples in C++ and Java. If you don't know UML two of the appendices will introduce you to it. The book takes a top down approach. You are first given a quick overview of agile development practices. I particularly liked the Testing and A Programming Episode chapters from this section. The second section presents five high-level design principles that every developer should learn and apply. Case studies dealing with a payroll system, weather station software, and testing software are then presented. Each case study section starts by discussing the design patterns that will seen in the case study. Section Four discusses subdividing the payroll system into packages. Six principles and a set of package Dependency Management metrics are covered. The book wraps up with the two UML appendices mentioned above, a comparison of two imaginary developments, and an interesting article by Jack Reeves. In my opinion Agile Software Development Principles, Patterns, and Practices is the best OOD book out there. Discuss book in the Saloon — More info at Amazon.com
Software Fundamentals: Collected Papers by David L. Parnas by Edited by David M. Weiss and Daniel M. Hoffman
Addison-Wesley Professional 1 edition April 2001 688 pages	Reviewed by Jessica Sant, June 2003 (9 of 10) Anyone who considers themself a Java developer should know who Dave Parnas is. Without the insight of Dave Parnas in the 60s and 70s there would be no such thing as the Java programming language. Ever heard of information hiding (the basis for all Object Oriented programming)? Yeah, Parnas came up with that. Exception Handling? That's him too. Interfaces? Parnas. (Get the idea?) This book reprints 33 of Parnas' most influential papers. Each paper is started off with an introduction from one of Parnas' peers (like Barry Boehm), giving the paper a connection to the modern state of Software Engineering, and trying to give the reader an understanding of just how seminal the particular paper was to the world of Computer Science and Software Engineering. I believe you become a much better programmer if you understand where things come from. Once you understand how things were before "Information Hiding" came about, you get a better appreciation for why its such a necessary and important practice. You'll become a better programmer because you're more aware of what would happen if you didn't have exception handling. And you'll be come a better writer when you understand why buzzwords can be so dangerous in technical papers. Dave Parnas has been a huge influence over the world of Software Engineering. Everyone should have the chance to read his work. Discuss book in the Saloon — More info at Amazon.com
Succeeding with Use Cases: Working Smart to Deliver Quality by Richard Denney
Addison-Wesley Professional 1 edition May 2005 336 pages	Reviewed by Jeanne Boyarsky, August 2005 (8 of 10) "Succeeding with Use Cases : Working Smart to Deliver Quality" walks you through four quality engineering disciplines: quality function deployment, software reliability engineering, model based specification and use case configuration management. Most of the book is readable by project managers, while model based specification (pre conditions, post conditions and invariants) is of special interest to developers and testers. As you can guess, the book assumes you already know about use cases. For the most part, the authors are good about going into detail without making any further assumptions of your background. Examples include concrete numbers and the diagrams are excellent. Once chapter does get theoretical and use algebra, but it is immediately followed by a practical application. Personally, I found the reasoning and walkthrough of the ROI example to be most valuable. The book does read like a short textbook and academics are explicitly mentioned as one of the target audiences. However, you can tell the book is written by someone who has been through it personally. Overall, I found the book to be a valuable read. Discuss book in the Saloon — More info at Amazon.com
Emergent Design: The Evolutionary Nature of Professional Software Development by Scott L. Bain
Addison-Wesley 1 edition March 2008 448 pages	Reviewed by Ulf Dittmer, May 2008 (9 of 10) The author states in the preface that he'd like to push software development as a profession forward by promoting a set of methodologies that are universally recognized as beneficial. This reviewer thinks he achieves this goal admirably and wishes he had had access to a book like this when he first started out with object-oriented software development professionally. A number of what might be called best practices are examined as to why they're useful, how they might best be applied, and how they deliver value in conjunction with other best practices. Some of these are well-covered by now (e.g. coding style and patterns), others are somewhat newer (like refactoring, the open-closed principle, unit tests and test driven development). At each step the author uses a combination of concrete code (mostly in Java, but easily understandable to everyone) and abstract UML-style diagrams to illustrate what is happening, and what difference a particular technique makes. One important recurring theme is that the waterfall model of software development is truly dead, and that change of all kind needs to be embraced in a project, especially including changing requirements. Every software professional will recognize the value of being able to cope with change, and in this book that's part of the core message at each step. I recommend the book to get fresh perspectives and new ideas about various parts of the development process, both for developers and managers. Discuss book in the Saloon — More info at Amazon.com
Documenting Software Architectures: Views and Beyond (2nd Edition) by Paul Clements, Felix Bachmann, Len Bass, David Garlan, James Ivers, Reed Little, Paulo Merson, Paulo Merson, Robert Nord, Judith Stafford
Addison Wesley second edition October 2010 592 pages	Reviewed by Wouter Oet, November 2010 (7 of 10) This book tries to provide a guidance on how to make your architecture understandable through documentation. The book is very complete, all the information you would expect to find is in it. But I feel that the authors took it too far. The amount of information can be overwhelming especially because it is spread over large pieces of text. The book can be hard to read because the language is very technical and the writing style isn't very entertaining. Luckily, the authors included a readers guide (advising you on which chapters to read depending on your background). The content of the book is good. It contains lots of quotes, sideline hints/tips and perspectives which are very useful. Also the usage of diagrams and examples make it much more understandable. The summaries, questions and references at the end of each chapter are a great addition. "Documenting Software Architectures" is very complete which makes it ideal as a reference book. It is not for the faint-hearted/beginners but is an addition to each architects bookshelf. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Murach's PHP and MySQL (Murach: Training & Reference) by Joel Murach, Ray Harris
Mike Murach & Associates edition November 2010 840 pages	Reviewed by Rob Spoor, February 2011 (8 of 10) The book follows the Murach style - on the left pages there is text, on the right pages there are screen shots, code snippets, and short summaries of the text on the left. For experienced programmers it's tempting to skip the entire left pages and focus on the right pages only. The book seems to be aimed at absolute beginners, as evidenced by the quite basic 6 chapter introduction. After that you'll learn the essentials of PHP and SQL. For experienced programmers there won't be much new information, but beginners will have a field day with these chapters. The book ends with some more advanced topics: security and authentication, sending emails, file handling and image processing. The book promises that you will "master" both PHP and MySQL. To be honest, it doesn't live up to that promise. It's good for beginners but it doesn't go far enough to call yourself a "master" afterwards. Several topics are handled too briefly, especially regular expressions and database normal forms. These are quite advanced topics yet they take up only 16 and 10 pages respectively. That's simply not enough. Another major flaw is the handling of SQL injection. It's mentioned briefly only once with the suggestion to search the Internet for more information. Given the lack of parameter validation in some examples I fear for security on web sites based on this book alone. One single page pair on the subject would probably have been enough. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Service Design Patterns by Robert Daigneau
Addison-Wesley Professional 1 edition November 2011 352 pages	Reviewed by Jan Cumps, January 2012 (7 of 10) There are a number of good books that teach you how to develop web services. But it is harder to find guidance on what architectural choices to make. And that is what this book is about. It discusses the options (yes: patterns) you have when working with services, what choices you have, and - the part that I found very helpful - what the implications of these choices are. It also tells you which design decisions bring you to the point of no return: once you make your choice, it will be hard to change to another approach later. The organization is very structured. The chapters follow a strict schema of describing the patterns. That makes it easy to use the book as a reference, but it doesn't turn the book into a swinging story. A good book if you need to make design choices, or if you want to understand merits and pitfalls of an architecture. It is not your book if you are looking for a web services implementation guide. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com

The Bunkhouse administrator is Ankit Garg.


Copyright © 1998-2013 Paul Wheaton, Missoula, Montana	Contact Us