“Many Excellent Chapters, Elvis Leaves The Building At Times”
The best audience for this publication is a programmer who approaches coding procedurally and needs to be directed in the way of believing object oriented. In fact, lots of chapters are flat out some of the best and clearest introductory material Ive read on OOP. Some of the middle chapters of the book are only rearranged words stating the exact same thing in circles. Youll read it thinking something new will come of it, but it doesnt. The latter part of the book are misc chapters giving a brief summary or discussion of matters like UML, XML, JSON, Serialization, Marshaling, Internet Services, and Design Patterns, and some of this is fresh in this fourth edition. These range from laughably cursory to excellent at times. A lot of that material is obviously for novices. The chapter on design patterns is probably the best introduction on the topic Ive read, however it does suffer from exactly the very same problems as the remainder of the book, as Ill note below.If you read the third variant, the same mistakes are there in this fourth. The editing problems are disappointing. Like page 223 he states, By now you must realize this is an actual application. . .The fact that the code comes with a main method in it is a sure tip. OK, well, the code doesnt have a main method. It leaves you wondering, What planet am I on, did I miss something? Another example: At the conclusion of chapters it seems like he inserts the wrong portions or strange choices of code. Just very inconsistent stuff like this. And there are things like sentences from prior paragraphs which reappear again almost word for word. Not to mention things such as sentences from prior paragraphs that appear to appear again practically word for word.I has been tempted to provide this book three stars because some of it is repetitious or useless and especially due to the editing issues. Despite its generous portions of genius, I didnt think the writer ought to be rewarded for putting so small research into it as a whole, particularly for what you would expect by a fourth rewrite! But Ill tell you, a lot of chapters are truly excellent for the ideal audience. Also on the positive side, the code examples are extremely clear and to the point. While ideas are often introduced with coffee samples, he also includes C# code also gives nice context to C++. It would be nice if the coding in the book was functional, but its usually the version that the world type of material which doesnt allow you to understand how object-oriented believing applies to actual coding.I should note that virtually every chapter references Object Oriented Design in Java from Gilbert and McCarty, printed in 1998. That publication obviously really influenced the writers life.
The Object-Oriented Thought Process (4th Edition) (Developer’s Library) Review | 0321861272 Review
“A Great Intro To Oop Along With A New means of Thinking…”
As this books title, The Object-Oriented Thought Procedure, suggests, object-oriented programming (OOP) involves a new method of thinking. Although the amount of developers who haven’t yet transitioned from procedural programming to OOP has to be somewhat small now (since the vast majority of current development jobs require at least decent knowledge of OOP), lots of beginning programming books, likely to conserve space, accentuate coding OOP rather than designing or thinking OOP. By comparison, this book not just solidifies OOP coding concepts, but it also accomplishes concepts of OOP design. Those looking for a way to energize their OOP power will come across a lot to munch on here.The novel opens with a subject that probably doesnt affect many new developers today: transitioning from procedural programming to Object-Oriented development. At the halycon days before the dominance of .NET and Java, OOP was not a required application development skill. An individual could program in C, Visual Basic (VB) or in several other non-OOP languages with no idea of classes or objects. This publication even argues that some early C++ developers were not using real OOP techniques, but simply writing C programs with C++ compilers. But once OOP Java broke into the mainstream and VB6 programmers realized they couldnt simply dive right into VB.NET as though it were just an update to VB6, the split between actual OOP developers and those who just dont get it originated. For the vast majority of beginning developers within the past ten years, OOP principles probably accompanied them from the start. Hence the moving from procedural to OOP problem will likely remain a mostly generational one. The segment nonetheless contains much helpful information about the differences between procedural and OOP.The rest of this book delivers a good coverage of OOP fundamentals. Many have corresponding code examples in Java, C# and VB.NET and UML diagrams. A few of the concepts will appear familiar, but the discussion goes far more in-depth than many novices books. Objects, classes, characteristics, encapsulation, data-hiding, approaches, object messaging, inheritance, polymorphism and other essential concepts get clearly elucidated with code and diagrams. Other topics usually not covered, at least in thickness, in beginner OOP coding books also look: essay (Has-a relationships), abstraction and interface vs. implementation. Some sections highlight object thinking, like thinking abstractly and in terms of item behavior.Later segments deal with constructors (a topic now important to Dependency Injection), overloading, class modeling, the golden fleece of reuse, maintenance, item comparison and marshaling. 1 section provides a walk-through of a real-world example, a Black Jack game, of identifying the essential classes, behaviours and attributes and how they should interact. An in-depth discussion of is-a versus has-a relationships helps elucidate the design principle to favor composition over inheritance or at least help determine when to most effectively use either notion. Later chapters put objects into various contexts, for example XML, persistence with databases, the internet and client/server applications. These segments are less in-depth and supply cursory overviews to provide one a taste of the technology presented. The final chapter presents design patterns, a vital topic for OOP design. Though it also remains at a really high speed, it does cover a few routines, though not deeply: Model/View/Controller (a currently dominant pattern), Singleton, Adapter and Iterator. Additionally, it introduces the concept of an antipattern, or how not to perform things.This book won’t make anybody an expert in OOP design, though its difficult to see how anybody can become a specialist without assessing the knowledge that it contains. Most of all, it highlights concepts which are not purely code-based and assists you think in fresh ways on how best to structure a program. Anyone with this feeling they havent quite absorbed OOP design principles ought to read this book end to end. The concluding chapter in design patterns also provides a perfect segueway into additional studies. Lastly, the book is currently in its 3rd edition, which appeared in 2008, therefore some of the advice here might seem out of date. A planned forth variant will tenatively look in March of 2013 that will cover unit testing, web services and mobile programs. Nonetheless, for people who cant wait, the 3rd edition still contains enough useful info regarding OOP to ensure it is worth a read today.