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.
"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,
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.
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.