Rating: 
Summary: Covering both features and shortcomings
Review: CFC are maybe the most important improvement coming from ColdFusion MX, bringing concepts borrowed from OOP to CFML. This book digs deep into CFC, covering both their great features and their shortcomings and it even uncovers a few bugs along the way. The author's main targets are developers used to CFML and procedural programming that need to get acquainted with the new, OOP-like, paradigm introduced by CFC. Still, seasoned OOP programmers may benefit from it as well, since CFC implementation diverges in many ways from many traditional OOP concepts. Compared to other books of similar size it can be a little overprized, but you should consider Techspedition is a very small, independent, publisher that really deserve our support
Rating: 
Summary: Trying to do three things at once
Review: Description"Discovering CFCs" is a slim book of some 160 pages. Curiously, the paragraphs are numbered. There are some 350 paragraphs in total, plus an appendix chapter. Quite a lot of space is given to diagrams, pictures, and code examples. There is an accompanying workbook in PDF that can be purchased from the publishers techspedition. The authors Hal Helms and Ben Edwards are known to the ColdFusion community as a writer in "ColdFusion Developer's Journal" and as one of the people behind Fusebox.
The book has ten chapters. The first is an introduction and the last a short story. The eight core chapters explain the object-oriented concepts, how to do object-oriented programming with CFCs, and the limitations of CFCs with some workarounds.
The code examples are often first in Java and then in CFC. In comparison to the Java code it becomes obvious how painful it is to program CFCs, because of the markup-language syntax and the limitations of the language. Helms and Edwards provide good discussion of some of those limitations, and provide workarounds for them. Among the limitations they work around are
* no private properties,
* no constructors,
* no super.
They also show how to use custom attributes and the meta-data to make self-documenting code. The book uses basic UML without making a big deal of it.
The last chapter is a fictitious conversation between three programmers about the pros and cons of object-oriented programming. It has a slight entertainment value, but doesn't really add much.
The book is aimed at CF developers who want to use CFCs. That is, they want to learn object orientation and how to do it with ColdFusion Components. Critique The book is trying to do three things at once:
1. Teach object-oriented programming.
2. Teach how to program CFCs.
3. Discuss limitations of CFCs and provide workarounds for them.
It would be better to do each of those things separately. A reader new to OO is likely to be confused by being taught an OO concept like super-class, then being shown an example in Java (a language that is besides the point of the book), then being shown the CFC code that takes half a page to do what Java does in three lines, and then the poor reader has to digest the limitations of CFCs and the suggested workarounds. What will you get out of the book? * Readers who don't know OO need better examples and less syntax problems of CFC. They should not read this book, but one of the good books about OO using Java as example language.
* Readers who know OO from Java or C++ or Smalltalk will find how to write CFCs. For them the OO stuff is superfluous. The book gives an introduction on how to write CFCs, but it does not cover the whole CFC syntax, so they will need the MX manual anyway. The book shows how to overcome some CFC weaknesses and that is useful. As concerns style, I personally don't like so many footnotes, especially if they explain important things like the definition of "method signature". Some examples are unrealistic: a cat that knows it can sleep, eat, and play, is a taken as an example of an object with methods.
Rating: 
Summary: CFCs won't harm the ozone layer
Review: Discovering CFCs is an essential read for any developer that wants to keep up with the movement to Object-Oriented Programming. While ColdFusion isn't OOP, and CFCs don't make it so, they are a step in that direction. This book clearly lays out the principles of OOP and shows where CFCs comply and depart. After reading this book, you'll have a much clearer understanding of CFCs and be ready to use them in your applications. Kudos to the authors for making a tough subject accessible and useful.
Rating: 
Summary: Out of date
Review: Do not buy this book, it is so out of date and teaches the wrong way of doing things..
Rating:
Summary: Rushed and Confusing
Review: Hard to believe this book had only two authors. A real dissapointment from Hal Helms after reading this Fusebox books.
Save your money and wait for something more concise and focused to come out.
Rating:
Summary: OOP Fleshed out into CF
Review: I agree with many of the other reviewers' comments about this book. It does probably have only 40 pages of actual text, the code samples span on and on. It starts off getting you excited about OOP by showing how exactly ColdFusion can preform PIE. It does do a good job of fleshing it out into CF code, even showing work arounds for OO concepts that are not currently available to CF (super, constructors, private variables). But you will reach the end of this book and think "How am I suppost to apply this to my web applications, my state-less, non-persistant web applications?"
The examples were great for writing a small app in Java or C++. The book doesn't give CF programmers practical examples of using OO in the web world. There is no clear vision cast to move away from procedural programming for web applications.
Rating:
Summary: Simple, short and powerful!
Review: I was a bit daunted at the prospect of learning anything about object oriented programming. The introduction of CFCs in CFMX seemed to really force my hand, and BOY was I glad to find this book focused solely on the topic. A lot of the other CFMX books I saw were huge and covered all aspects of CFMX. This book was a focused treatment of CFCs in depth and done in a way that let me approach the basics of OO in a comfortable enviroment.
Rating:
Summary: Techspedition has done it again.
Review: Techspedition has done it again. In a refreshing and clear style, co-authors Hal Helms and Ben Edwards welcome readers new to all things object-oriented to the exciting world of ColdFusion Components. This book serves two purposes very well: Making object-orientation easy to grasp and thoroughly discussing ColdFusion components. Although it can be a quick cover-to-cover read, don't be surprised to find yourself dog-earing pages, underlining sentences, and propping it open on your desk as a reference to implementing CFCs in real applications. Bravo to Techspedition - I can't wait for the next in the series!
Rating:
Summary: Rushed and Confusing
Review: This book is completely worthless. You are better off reading the documentation in ColdFusion about components. The examples are very simplistic and do not help to address why and how to use components in real-world applications. There are also dozens of mistakes, including spelling, grammar and in the code examples which often make the examples difficult to follow. The numbered paragraphs are useless and seem to serve primarily as a way to increase the number of pages in the book. (If you do not include the code examples, this book probably contains only about 20 pages of writing.) If you do buy this book, I implore you to skip the "Closing Thoughts" section which is an imaginary conversation between 3 developers that rambles on for 10 pages yet says nothing of value. I will say the book is aptly titled: it helps you "discover" CFCs, but it does little to make them useful. I am considering sending this book back and asking for a refund. It's that bad.
Rating:
Summary: CF Enters the OO World
Review: This is a very important book for ColdFusion developers, as we begin the inevitable shift from procedural to object-oriented programming. Discovering CFCs covers the whole topic: from an introduction to OO and CFCs, through simple examples, and on to complex heirarchies of CFCs. It also points out the problems and bugs with CFCs as they exist now, yet another reason to pester Macromedia to stick with CFCs and fix their problems. Overall, a must-read for any ColdFusion developer who is interested in staying current with their skill set now and into the future.
| 
