5 comments about An Introduction to Web Design and Programming.

1. I have been teaching Web related courses for several years now. When I received a note from the publisher's representative annoucing the textbook, my first reaction was "Another Beauty From Paul Wang" and I was right! I have copies of all books written by Paul Wang including the best-seller, five-stars book (ANSI C on UNIX). Finally, there is a book that I really can use in teaching courses on both Web Design and Web Programming. Most existing books either discuss Web Design or Web Programming but not both. I have adopted the book and I will be using it to teach my Computer Science students as well as my MBA students. The book is well-written, comprehensive, and probably is the first book that is written by people on both sides of the aisle: Arts and Computer Science. I have always believed that most computer science folks lack the artistic side of Web publishing and many people in the arts field lack the technical side of it. I believe the two authors (a well-known and famous computer scientist and author Paul Wang and a leading expert on Visual Communication Design Sanda Katila) have done an excellent job and provided us with a wonderful textbook that addresses the subject of Web development in an integrated manner. This textbook can be used by almost anyone who is interested in Web development. It is easy to read and follow and it is very interesting. Yet it is challenging and very informative. I highly recommend this book and give it a Five-Stars rating without hesitation.



2. This is an excellent book that covers all aspects of web development. To often are programmers unconcerned with the aesthetics representing the code they create. However it does not matter how functional your site is if the user cannot enjoy it, understand it and navigate it. That is where this book fits in. It is the perfect medium between the programming world and the design world. If read cover to cover this book can give even the most inexperienced reader the skills needed for professional web development. It is well organized and laid out in a manor perfect for the classroom environment. I highly recommend this book to anyone interested in web development.



3. This is an excellent book that covers all aspects of web development. To often are programmers unconcerned with the aesthetics representing the code they create. However it does not matter how functional your site is if the user cannot enjoy it, understand it and navigate it. That is where this book fits in. It is the perfect medium between the programming world and the design world. If read cover to cover this book can give even the most inexperienced reader the skills needed for professional web development. It is well organized and laid out in a manor perfect for the classroom environment. I highly recommend this book to anyone interested in web development.



4. The book is well written and concise with many wonderful examples to support the text. The combination of both web design and web programming into a single resource is inspired.



5. To see the book cover, detailed table of contents, and
   a rich set of supplemental materials please visit the
   book site: sofpower.com/wdp

5 comments about Design Patterns in Java(TM) (Software Patterns Series).

1. Metsker, in collaboration with Wake, has released a counterpart to his earlier book, "Design Patterns in C#". Essentially, it covers the same design patterns, but now implemented in Java code. The authors readily point out that the book is directed at a new or intermediate Java programmer. Experienced Java coders probably [or should] already have written such patterns, based on their prior knowledge.
   
   The book takes you beyond the elementary syntactical issues of Java. The pedagogy also includes frequent problems interwoven into the text. These have answers! [At the back of the book.] One reason given by the authors for including the problems is simply that you can get good experience with patterning, if you tackle them. A cheaper and safer alternative than trying out patterns for the first time on actual workplace problems.
   
   None of the problems are very intricate. But they expose enough of the essence of the patterns for your understanding.
   
   Of course, aside from actual coding, patterns are now forming part of the standard vocabulary of professional programmers. If you are not a programmer, but have to interact with them, then the text can be good background.



2. If you're a Java programmer and want to approach the subject of design patterns from that perspective, this book is very well done... Design Patterns In Java by Steven John Metsker and William C. Wake.
   
   Contents: Introduction
   Part 1 - Interface Patterns: Introducing Interfaces; Adapter; Facade; Composite; Bridge
   Part 2 - Responsibility Patterns: Introducing Responsibility; Singleton; Observer; Mediator; Proxy; Chain of Responsibility; Flyweight
   Part 3 - Construction Patterns: Introducing Construction; Builder; Factory Method; Abstract Factory; Prototype; Memento
   Part 4 - Operation Patterns: Introducing Operations; Template Method; State; Strategy; Command; Interpreter
   Part 5 - Extension Patterns: Introducing Extensions; Decorator; Iterator; Visitor
   Part 6 - Appendixes: Directions; Solutions; Oozinoz Source; UML At A Glance; Glossary; Bibliography; Index
   
   Wake and Metsker use the same standard patterns that have been popularized in the Gang Of Four patterns book. But the main difference between that book and this one is in the application of the material. After you get a very clear understanding of the goals of a certain pattern set, they explore the implementation of that pattern using Java coding examples. That's the value that sticks out for me. Rather than dealing with general abstract coding philosophy, you end up with concrete examples, real business scenarios, and working code that illustrates the concept. Granted, the "real business scenarios" are most applicable to running a fireworks factory, but it's better than "dog is a object of class mammal" fluff that doesn't bridge well to where we live on a daily basis...
   
   This book can definitely stand alone when it comes to learning all about design patterns. But if you've read the classic and still don't "get it", this book will tie it all together for you... From the Java perspective, it'd be hard to go wrong here...



3. I've heard a lot about the classic "Gang of Four" Design Patterns book. However, while I've read many papers based on it, I've never actually read The Book. So, when I had a chance to read the new Design Patterns in Java(TM) (2nd Edition) it seemed like a perfect chance to load up on some must-know information as it is applied to my programming language of choice. Excellent!
   
   This book merges and updates the Design Patterns Java Workbook and Design Patterns C#. Design Patterns in Java is targeted at developers who know Java and want to improve their skills as designers. It covers the same 23 patterns discussed in the Gang of Four Design Patterns book.
   
   Patterns are powerful things. As the Metsker and Wake put it, "Patterns are distillations of accumulated wisdom that provide a standard jargon, naming the concepts that experienced practitioners apply." Exactly! They authors have a way with words. I really appreciated the one sentence descriptions of each pattern at the beginning of each chapter. These helped me to immediately grasp the intention of each pattern before digging in to the details. The periodic "challenges" throughout the text are thought provoking and worth the effort to work through.
   
   The advantage of this Java-centered book over a general patterns book is that it helps you understand how Java's unique features can be used to implement the patterns. For example, sorting can be implemented using polymorphism and the template method pattern. The original GoF book is a classic. Design Patterns in Java is, for the Java developer, the perfect combination of the GoF book's concepts with concrete Java implementations to make it all easier use. Not only are there Java examples but the book also includes information to help you refactor your existing code to use patterns. Very helpful.
   
   The appendices include solutions to the various code challenges, information to access the sample site's source code, and a crash-course in UML.
   
   I love the suggestion at the end of Appendix A: "Decide how many hours a week you want to spend on your career. Take five hours off the top and pay yourself first. Spend that time away from the office, reading books and magazines or writing software related to any topic that interests you." Great concept!
   
   If you're a Java developer looking to invest some time to improve your design skills, this would a great place to start.



4. I found the book quite useful. I especially liked that the book is Java based as that is the language i primarily use and that code examples are provided. I learn by doing and the book is excellent at giving the reader the opportunity to implement patterns. This book is more than just theory. It's practical.



5. First off, the content/material in this book is great and very helpful for starting to bridge the gap between being just a Java programmer to becoming a system designer.
   
   My biggest problem with this book is its format/structure. You cannot read it straight through (linearly). There are questions and challenges scattered throughout each chapter that force you to flip to the back of the book to see the answer because there are not enough supporting examples in-line. IMO, sometimes there is not enough information before the question/challenge to answer it (especially if you're not very familiar with Design Patterns); this forces you to check the back of the book every few pages, which can be very annoying. I was hoping for a book that I could read straight through, not a workbook.

5 comments about Pragmatic Unit Testing in Java with JUnit.

1. This book is very good for a beginner to unit testing. I like the simple explanation of the different types of unit testing that must be done. This really helps a beginner to make sure that the tests are comprehensive.
   
   Also it clarifies the intention behind use of mock objects. I would use the concepts in this book as a checklist to make sure the tests are written to cover all types of problems.
   
   I gave 4 star only because it contains toy examples and does not go into too much detail on this very important topic. JUnit Recipes contains more realistic examples.



2. This is another fine book from the "Pragmatic Programmer" series. If you are doing Java development, but haven't gotten into unit testing yet, this is a great place to start. The book is a quick read - I made it through in two days. The book gives background on why unit testing is important and then tells you how to go about doing it with JUnit. The book has practical advice for the kinds of things to include in unit tests while it finishes with design considerations for make code easier to test. To get the most out of the book, you need to download the code from the author's web site and work through the exercises. It is great how they have taken a critical topic and made it extremely accessible. I highly recommend it.



3. JUnit Testing can really save you a lot of time debugging. This book provides a various way to work with JUnit.



4. pragmatic Unit testing in java save a lot of time to debug java code.



5. Buyer beware. This book does not reflect the many changes to JUnit implemented in version 4. I found it to be a very good book when it came out four years ago however.

5 comments about JBoss(R) Seam: Simplicity and Power Beyond Java(TM) EE (Prentice Hall JBoss).

1. This is a very good book for learning about SEAM, a web framework that I would consider one of the best for its simplicity and power. However, what this book is best at is teaching you the basics of SEAM (though is some areas, such as stateful navigation rules, it doesn't go deep enough).
   
   Where this book lacks most is as a reference book. The reason for this is that many concepts are introduced well before the chapters that talk about them. When looking back at these concepts, I find myself having to find the first place the concept is introduced because the chapter about that assumes that you have read the earlier introduction.
   
   Overall this is a good book for learning the basics of SEAM. However, it is not a good in-depth reference. Nevertheless, SEAM is an excellent technology and there are not yet many good books on it. This book will bring you up to speed on SEAM pretty quickly so I still recommend it.



2. Its a great book.. It difficult to learn Seam without this book.
   It may be slightly dated, with Seam 2.0 coming out recently.
   But per the author, there are not significant changes in the code
   ie mainly config changes.
   (eg they recommend JPA with tomcat instead of embedded server option
   with tomcat)
   
   Seam(and specifically seam-gen) still has some significant bugs/issues
   to iron out(but workaround exists).



3. It's not a cookbook with ready made recipes. It gives a shallow but complete overview of the Seam framework features. That is important because if you don't know it exists you will never try to use it. Examples: XHTML validation tags for Hibernate, conversation state, and much more.
   
   It's a must read to get a good start with Seam and to learn what WebApp development should have been from the beginning.



4. Compared to other computer books this book is to shallow and does not cover the depths of Seam. I would like a more continous example throughout the book instead of a collection of small, rather trivial examples.



5. Very good book. It gives good knowledge about how to write
   applications in this framework. Many working examples are also
   appreciated.
   
   In the beginning authors explain what is Seam, and it is understood,
   as Seam is much different than any other framework with similar
   functionality. Seam is not meant for using it as "white box". It is
   rather "black box", designed for just using it, without knowing inside
   details. Because of this debugging Seam code is tedious task, and in
   fact unnecessary. There is chapter in the book explaining how to use
   debugging mechanism built in Seam, so called "debug pages". One can
   check session state, stacktrace or JSF components tree. Very helpful
   for anyone writing web applications in this framework.
   
   There is also chapter about business processes and business rules.
   Yes, this is also built in Seam. As an example in the book is ticket
   system. User logs in, lists tasks and assigns them to herself.
   Developer does not need to care about storing users tasks in database,
   it is enough to set component scope to BUSINESS_PROCESS. This is very
   interesting functionality, and although it is explained quite well in
   the book, I would like it to be explained even better.
   
   There is good testing support in Seam and this is also well described
   in the book. Seam provides tools to do in tests what is normally done
   by container, like dependency injection, database and transactions
   mocking etc.
   
   Another chapter is about running Seam applications on non-ejb3
   containers (like Tomcat).
   
   The book covers many topics, not only about Seam itself, but also
   about how to use Seam, test, how to deploy applications on non-seam
   container, how to connect to another than default database etc. The
   book is targeted for real users, for people working with the
   framework.
   
   What I miss is more insight into how Seam internally works. Such
   knowledge is not necessary to write working apps, but I just like to
   know such things.
   
   Some knowledge about JSF and EJB3 is also very useful when reading
   this book. I would like some of this stuff explained, but on the other
   hand it is book about Seam not about EJB3/JSF.
   
   I think reading this book is very good for someone who wants to write
   applications in Seam, even advanced ones. Seam is interesting
   technology, much different than pure JSF+EJB3, and it's worth
   learning, even for someone not using it at work, just to see new
   possibilities.

5 comments about JavaScript Bible, Fifth Edition.

1. An overwhelming amount of information without a simple beginning. The author jumps from beginning level information to way too sophisticated so fast that it will lose any non-technical person.



2. Definitively it's the javascript bible.
   
   If you want to fine tune your AJAX apps you'd better buy this book.
   
   It's extensive object and fuction reference does not leave anything in the shadows.
   
   This book is worth every cent.



3. This "Bible" covers everything that is needed for JavaScript programming. Everything is very well written and very easy to understand with clear code examples and real world applications. The beginning tutorial is a great way to get beginners started then the more advanced topics are covered in the Book or on the CD with all of the examples listed on the CD as well.
   
   This is a book that I will continue to use.



4. Pro: really good reference work for most people
   Cons: 1) Not for someone who doesn't know either javascript basics or another scripting language. 2) Organization is good, but it isn't an encyclopedia and it isn't a start-to-finish tutorial. 3) Poor typeface decisions.
   
   This book is the greatest for several different types of people. First, anyone who knows the basics of javascript, from advanced beginner to advanced js user. Second, anyone who wants to learn javascript and already knows some programming; you can use it as a tutorial, but only if you don't need much explanation about scripts and object-oriented programming.
   
   It really is just excellent for someone who has previously learned something about one of the chapters but needs a refresher and/or more detailed/comprehensive walkthrough.
   
   Four stars instead of five for a completely unnecessary mistake. Unfortunately, the W3c ignores people who do not have eagle-sharp vision and will fill a page full of semicolons and colons, or parens and curly brackets. If you don't have a font that clearly distinguishes these, it is a major source of semantic errors and eyestrain. The font chosen to print the code in this book could not be worse. Colons and semicolons are almost impossible to distinguish (not to mention periods and commas),and curly brackets look like thin lines with no curls.
   
   C'mon guys. There are fonts of every type where periods and commas are easier to distinguish, and curly brackets have a distinct shape. USE THEM FOR PUBLISHING CODE!!



5. I own several Javascript books, all of which seem to be littered with mistakes, and code that doesn't work across all browsers, except for this one. Developing web pages is the hardest of all development technologies, you have to know a lot about different technologies, and make them work across all browsers. Thankfully Netscape, which was a major problem in the past, has come a long way and caught up to the rest. However, making Javascript work for each browser is hard enough, and this book really comes to the rescue. It tells you what works for which browser. The authors have done their research, and has helped me tremendously with the work I do for my clients. I will continue to support the Javascript Bible series, and I hope the authors continue to produce a great reference.

5 comments about Java Messaging (Programming Series).

1. As we look at how much we use the web, it is sometimes hard to remember just how new this concept of worldwide packet switching really is. Java was started as a new language before a lot of the new concepts like XML and SOAP were conceived. But as a new language it has been able to move into using these new concepts faster than nearly any other language.
   
   What I especially liked about this book was the first chapter. So often computer books start with programming. This one starts with a description of what we're trying to do here. He gives several examples of the types of communications that he is going to cover in the book. I had a particular application in mind when I got the book, but in reading the first chapter I began to see several other ways that messaging would help our system.
   
   After the first chapter, I've go to say that it's a pretty regular computer software book. It tells you how to do the things that you want to do. It is quite clear on all the different software protocols, packages, and philosophies. Basically it is all that a Java programmer needs to implement messaging in Java.
   
   The CD included with the book gives you all the sample code from the book, as well as the complete messaging toolkit and several open source tools.



2. Eric Bruno's JAVA MESSAGING explores different ways of messaging using Java software, from JavaBean events and JMS to SOAP. Web programmers receive all the basics to using these features, tips on how and why to use each feature and when to choose something else, how to combine features, and more. The basics of Java communication processes are revealed in chapters which form 'classes' to link related information in a logical progression. An excellent, basic foundation for Java users.



3. Excellent introduction to messaging, including healthy portions on JMS and web services.
   
   The writing style is clear, consistent, and to the point. Probably what I liked most was this no-nonsense writing style. If it's on a page, it's important to understand. The author doesn't waste your time with irrelevant discussions or out of scope topics.
   
   Editing and code presentation are top notch, making it easy to follow, and build upon from one example to the next. The author also shares some gotchas and considerations that I wouldn't have expected to see in an introductory discussion which were particularly valuable.
   
   Another great feature is one of the drawbacks of the book. The framework presented in the book is elegant, but in many of the examples, there is too much cognitive overhead involved in grokking the level of abstraction in the framework, and this takes away from actually learning the concepts. I would have liked to see more non-framework code for the introduction, which is then tied together with the framework.



4. Although the book uses a specific JMS engine for the examples the details and the concepts were all right on and covered everything I needed for JMS. It literally saved my bacon, especially the peer to peer stuff over topics. Whew!
   
   Super job.
   
   Sam



5. As other reviewers pointed out, this is indeed a nice work on Java Messaging. For the most part, the concepts are presented clearly and I had no trouble following them. What's good about this book is that there are enough examples to play with and most of them indeed work as promised in the book. This book uses ActiveMQ 2.1 for JMS Provider while the current version is 5.x. However, the ActiveMQ 2.1 libraries are included in the CD, so using those you will have no problem in running most of the examples. I could not get the examples that use Java Web Service Developer Pack (JWSDP) to work however (chapters 8 and 9). This book uses JWSDP 1.4 version which I could not find on the web (at the time of this writing only JWSDP 2.0 is available for download on Sun's site). The book says that JWSDP 1.4 is included on the CD but it was not. Except for these minor issues, this book is worth reading and owning. Highly recommended.

5 comments about Java Concepts.

1. An excellent intro to programming from an outstanding author and programmer. It keeps reasonably upto date with the latest java version and presentation trends (pages are so full of color that reading it reminds me of a kid's birthday party.. personally I hate it, but it seems that's the current fashion..). My only problem with this book is its price and outrageous selling strategy. This book, as well as Big C++ and Big Java sell for 80 to 90 bucks in the US, where they can be imposed to college students as textbooks. Here in Italy, where this trick can't work they sell for their real value, that is from 40 to 50 bucks.
   So, exploiting the enthusiasm of the student buying his new textbooks (I know how it feels I have been there myself) or just the plain fact that it can be imposed as required reading in some classes this text is oversold at almost double its real market value. I find this disgusting. Unless you are forced to adopt this text, go for a maybe less academical and colorful book (but reasonably priced ) by the same author, Core Java.



2. I use this text for an AP Computer Science course, and find it to be one of the most confusing books on the topiic of Java and Computer Science. Being in multiple APs, I obvisouly cannot read every single word and frequently have to sort out what information is relevant in a book. In most of my textbooks, this is rather easy. Horstmann's book is, however, quite the exception. The authos literally interupts his own sentences and sections with dozens of "Random facts," "Productivity Hints," "Advanced Topics," and many more of these litte interuptions. One chapter, I forget which one, actually has three of these strung in a row, manking this book incredibly hard to read. After cutting out in the middle of a topic, it is very common to just, without warning, start back up five pages later. Avoid this book.



3. This text is a nightmare. Terms are poorly defined, if defined at all, and examples are few and far between. The illustrations are laughable. I've seen better graphics in nursery books written 30 years ago. If your professor assigns this text, and you're new to Java, be prepared to shell out more bucks for better sources or cruise the Internet to get the answers you need. This book won't provide them.



4. If you've read "The C Programming Language" and enjoyed the style of its presentation, you'll likely find this book appalling. The book is neither concise, nor lucid; you wade your way through endless explaination and come out with little understanding. I've found the examples and the presentation on Sun's website to be much easier to understand, simply because they start with a clear example, discuss it a bit, then give the details of each statement (much like Kernighan's book).
   
   Also, some of the code can't simply be typed in and compiled. In one section, they fail to mention, either in the text or in the example, that you need to import a certain class. The documentation on Sun's website is excellent, but that shouldn't make it acceptable to leave details out of the text.
   
   Finally, the price is a total rip-off. I was fortunate enough to get the book used for under $20, but I would feel cheated if I had paid more. A lot of the information can be gotten for free, and that the quality of the free information often exceeds that which is in the book. Sadly, this book seems to fit the "intro to programming" niche, and a lot of students will be forced to buy it for those classes, allowing the publisher to get away with the high price.



5. There are lots of people dissatisfied with this book, myself included. I really don't understand how anyone can find this book cohesive, and the little bit of information you get out of it you have to dissect the text for hours to get any meaning from it. This book loves to give you code to use and not tell you what in the world it does, just that you need it. So you use it for chapters then boom, in chapter 9 your finally tells something about it. That is not constructive. The learning process does not work this way. Most of the time the book hardly tells you anything. You can see that certain things must come before others, but not told why and with out being told what the code really does; its mostly just guessing why. I understand that the goal of the book is to teach programming and not a specific language, but this book does not successfully do that when it doesn't tell you what is going on. In my opinion, it confuses you to what is going on and you have to "unthink" what you've learned to actually progress with another book. I gave up completely on the book for my class and turned to outside sources to pass. Most of my classmates have been forced to do the same.

2 comments about JavaScript(TM) Step by Step.

1. This book was a great for a beginner to Java Script. The exercises were easy to follow and were relevant to real world problems that you may need to solve. The author keeps things lite and keeps the material interesting. Not only is this written for beginners with little to no programing experience (like me) but I can definitely see coming back to this book as a reference as I continue developing with Java Script!



2. I'll agree with Chris from Minneapolis. This is a great book no matter what level of scripting experience you have. I had/have very little java scripting experience and with this book, it's very simple to learn in a fashion that is geared more toward real-life situations, vs. just some script that a professor or teacher wants you to write that has no meaning besides giving you work to do. GREAT BOOK, RECOMMENDED TO ANYONE OF ANY LEVEL OF SCRIPTING EXPERIENCE!

1 comments about Small Java How to Program (6th Edition) (How to Program (Deitel)).

1. This book is very good for someone who needs examples and explanations of sample code. I found this book very easy to read. I will use this book as a supplement in my class. It provides a different way of explaining material that would sometimes be confusing. I like that this book breaks down every line of code and explains it to the novice programmer.

5 comments about Agile Java Development with Spring, Hibernate and Eclipse (Developer's Library).

1. This book tries to combine so many things in to one. Thus it looses the detail any technical person would like to see. It skims over Extreme Programming, RUP without saying much about it - it is understood as it is not the focus of the book.
   
   The architecture it discusses is just a three layer one, which I believe any programmer would know before hand. This talks about lot of freewares and then it goes through Hibernate and Spring, which I believe is not enough for a technical person. The books can be used for overall idea for a manager or a programmer who is totally new to the concepts.



2. I like the concept of this book. Combining a whole bunch of ideas that these days are well proven and likely to result in well written software and productivity gains.
   
   Agile, Java, Eclipse, Hibernate, Spring. All stuff that I am working with right now. Seems the perfect book to fill in the gaps in my current knowledge.
   
   Unfortunately, though the author may be a fine developer, he is not a great writer. This book to me had serious flaws, and unfortunately, I learnt oh so little.
   
   The book barely scratches the surface, glossing over any real detail and bringing not much more than what you'd get reading the home page of the respective products.
   
   Some may like the ultra-casual writing style, but I found all his diversions and personal asides distracting. Granted, it's easy to read when the writing resembles that of a spoken conversation. But I found the book to be disorganised, fragmented, and having a rushed quality to it. And just too lacking in depth.
   
   I realise that the author was attempting to cover a lot of ground (as he points out more than once) but this book could have been so much more concise. For example, he wastes his (and my) time reviewing alternative IDEs when already admitting he is totally smitten with Eclipse. If the author just hadn't been so keen on personal asides and spent a bit more time getting the structure of the book right, he could have covered the subject matter in much more detail.
   
   OK, so this book might be good if you want a crash-course in all those fantastic open source products. It might save you some time in getting your basic application up and running, if you've never used any of these products before. But if you're already familiar with them, or don't mind reading some online documentation, or don't mind having a quick play yourself, then your hard earned cash may be more wisely spent elsewhere.



3. Somewhere in the initial few pages, the author give his readers a few options before reading (or buying for that matter) this book. One of them was to trust his advice, agree that Spring+Hibernate+Eclipse are cool technologies and scrap the idea of this book.
   
   I continued reading but now I recommend accepting his idea and save some bucks or buy something more useful, maybe separate books on Spring and Hibernate (btw, Spring in Action 2nd Edition is now available). All of these are surely good technologies but the book never goes into detail of any one of them (and it was not supposed to) and for installation/setup refers you to "latest installation instructions".
   
   Without the depth of details on any particular technology, and lack of instructions on making you up and running makes this book feasible only for a small window of people who want to try out and be "convinced" themselves personally before eventually buying separate books on each technology.
   
   I did not comment on the content because content comes after the 'purpose' of the book. For me its a two-star book and does not even require a content review (read other reviews for content if you really want to buy this).



4. I can not believe how anybody who has read this book would honestly give it a 5 star. I read the whole book, waiting for that moment that I could say: Oh, that's what the author meant by repeatedly saying: "more to come later" or "we'll see this in later chapter" etc. That moment never arrived. This book looks like a hurried and lousy compilation of 5 day presentations on each subject that this books claims to cover, without proper editing and attention to detail.
   I read the book riding the metro in Washington DC and I can honestly say that I would rather see DC tourists block the left side of the escalators in the metro stations on a busy rush hour day than read or refer to this book again



5. This book tries to cover too many things. The book is more a Manifesto for Agile Development from an experienced programmer than a technical book.
   
   Thus this small book misses all the details any technical person would like to see. The book is definitely not a comprehensive API guide to Spring or Hibernate, nor does it intend to be. The author repeatedly said : "more to come later" or "we'll see this in later chapter" etc. But that moment never arrived...
   
   The books can be used to get an overall idea for a manager or a programmer who is totally a newbie to the concepts.
   
   The more interesting part is on Agile Development where it seems to be a Manifesto but definitely not a tutorial.