Customer Rating:  
Summary: Did APRESS review this book before publishing it?
Comment: Don't buy this book. Poor english, terrible analogies, no structure. After reading it for a day I had to stop myself from banging my head against the wall. Christian Gross tries to explain technical concepts with real world analogies such as going through shopping malls, having an instance of your private wallet and publicly exposing your credit card, limiting the public access to charging your account. He then goes on to try explaining "static" methods with a push-to-talk family phone analogy. All his analogies are confusing, and I cannot see how anyone can grasp any of the technical concepts without having a solid background. The problem is, if you have a solid background in programming, then the analogies are useless. If you don't have the background, they are even more useless. Sorry Christian, but you really messed this one up. So did APRESS and the technical reviewer Christian Kenyeres.
Customer Rating:
Summary: Very Disappointed...
Comment: I made it through only the first 25% of the book, and I could take no more. This book is really quite bad.
Just a few of the things that make this book so bad: 1) Rambling and EXTREMELY confusing analogies that destroyed any chance of me actually understanding the material. Though I think that the author was trying to draw comparisons to everyday things in order to help a beginner understand the material, he failed miserably. A few simple drawings and basic descriptions of things like memory, stack, heap, etc. would have served the reader much better. 2) Code and terminology are used but never explained. Though I understand that learning a language requires referencing multiple sources, and I do it often, there was simply too much unexplained terminology and too much code that was never explained and was not found anywhere else in the book (e.g. Assert.AreEqual). 3) Typos and mistakes: In the midst of all the confusion caused by the writing style, there are also typos and editing errors that ensure complete confusion. As an example, there are block diagrams in which sections of code are pointed to and explained, but in some cases the wrong portion of code is pointed to for a particular description. I also found incorrect code results that belonged to other examples later in the book. Obviously they copied and pasted without paying enough attention. 4) I could continue, but there is just too much.
I do have one positive comment. I very much appreciate the author's emphasis on testing and code organization. I think it is a valuable subject that is overlooked by many. This is the only reason I gave this book a rating of 2 rather than a 1.
Customer Rating:
Summary: Can't believe it! A 2nd edition on the way
Comment: I am totally dumbfounded at Apress. I have the VB version of this book. And from these reviews I can tell both books are similar. Meaning after reading some sections you will be left saying to yourself, "what just happened"?
As several have noted thru the constant use of analogies, the author takes you far down a beaten path that is typically very far from where you want to be. You end up trying to think exactly like him to try to understand what his analogy is trying to explain. Very bad writing style.
The examples he does use to try to demonstrate programming principles are bad also. I have been working in Java for sometime. So I have an understanding of Interfaces vs. Inheritance. With a good understanding of this particular topic, I found myself very confused reading some of his chapters that try to discuss Object Oriented principles.
If you check some of the other books this author has written you will see a general overall rating of 3 at best due to his poor writing style.
I used to heavily recommend any Apress book on any given topic. Seeing as Apress is coming out with a 2nd edition of this throwaway book, I can no longer abide by that. Will never buy an Apress book until I've had a chance to read some samples in a bookstore, or read several reviews.
Customer Rating:
Summary: Stupid book I have ever seen
Comment: After reading some parts, especially the part about inheritance and polymorphism, I have to say that this book is not for beginners, even not for advanced developers. This book leads people to wrong way to design. For example, The Shape, Rectangle and Square relationship is discussed in very complex and abstract way that the readers can't understand even if they read that portion 10 times. The author tried to explain the "good" way of component level development using that example and spend a long time on comparing different approaches. While summarized that all approaches have shortcomings if simple inheritance and polymorphism is used, he suggested using a new way called "component level design". But, believe me, he didn't provide the component level solution for this problem finally and you will be left totally confused. If you check another examples in this book, you will find them very uninteresting and ugly.
Don't buy this book if you want to learn something.
Customer Rating:
Summary: Analogies
Comment: On the first read through of the book, a few things hit me:
1. There are way too many analogies that became increasingly frustrating and tedious to read through. Personally, I want to learn what, why, and how -- not just what and then be given analogies as to why and how. This is a personal gripe and may not hold true for others.
2. Some things are not completely explained. Ex. pg 61: When explaining hashcodes, no information is given on what exactly the value is derived. An analogy about wine glasses is given rather than the exact reasons.
3. I've got to say there are definitely some gems in this book because of the way it is presented. At the same time, the presentation is the downfall of the book. I don't want to seem overly critical, but I would have liked more facts rather than analogous views on why things work the way they do. It's like digging through mud to get to the gems, though the good information this book provides is worth it. These gems include common real-world examples and advanced features in the IDE.
4. The book definitely holds your hand and never over-immerses you. This is a plus. Though, sometimes, I felt that if I didn't have a programming background I would have had to re-read passages many times (this could just be due to the learning curve of programming in general).
5. I fell in love with the end of each chapter. It gives you questions that may seem impossible to answer with what has been given you in the chapter. The answers can be found online and are in depth. These questions and answers completely further the learning!
Thanks for writing this book! Although, I can't say I agree with the use of analogies, I can understand it from a teaching perspective.
|
|
