Rating: 
Summary: Excellent, well-written introduction to Fusebox and FLiP
Review: I wrote the foreword to this book and was very impressed by how well-written the book is, as well as the excellent structure of the information Jeff and Nat present. The book uses a single project to introduce readers to the Fusebox method of discovering what the client wants, creating the right architecture, and implementing the code.The book is very accessible and readers will find their questions about Fusebox and FLiP answered thoroughly. Highly recommended.
Rating:
Summary: Fantastic Reference, especially for FLiP
Review: I'm about 1/2 through this book, just starting the chapter on Prototypes and I just can't say enough about this book. Great reference for what happens inside the Fusebox core. Fantastic reference on the FLiP process, all compiled into one location to read through. It's already changed the way I'm developing!
Rating:
Summary: Fantastic Reference, especially for FLiP
Review: I'm about 1/2 through this book, just starting the chapter on Prototypes and I just can't say enough about this book. Great reference for what happens inside the Fusebox core. Fantastic reference on the FLiP process, all compiled into one location to read through. It's already changed the way I'm developing!
Rating: 
Summary: Great Book
Review: I'm new to Fusebox and have found this book indispensable in learning about it. After working through the Fusebox chapters, I put it down, not being very interested in the FLiP stuff. Then I picked it up again later and wondered what I had been thinking! To me the FLiP chapters are more important and might even be placed in front of the Fusebox chapters. So many projects have I worked on where the imposed methodologies have been ad hoc at best. A better title might be: "Fusebox and FLiP: Developing ColdFusion Applications". I only gave 4 starts because I kept wanting more concrete examples in the book (especially regarding nesting). (I have only just downloaded the examples and perhaps they will fill in some of these holes.) Overall, I highly recommend it. PS: Looking forward to examples using CF MX! :-) Jamie Orchard-Hays
Rating: 
Summary: Not much help
Review: If you are new to fusebox you will probably read this book cover to cover and step away knowing nothing of practical value. This book could be useful as a high level reference for an experienced fuseboxer but not much else.
Rating:
Summary: Good; I wish it had been published last October...
Review: Jeff Peters and Nat Papovich have both been major forces in the development of Fusebox -- a methodology for developing web based applications in an efficient and organized fashion. While build and primarily used with ColdFusion, Fusebox can also be used with PHP or JSP code. [There is nothing available for ASP - arguably the most popular web scripting environment - due to limitations in the ASP language. ASP is unable to dynamically include files.] This book provides a good introduction to Fusebox 3, as well as the FLiP methodology. They spend the first 100 pages or so walking through every line of code that is executed to initiate a fuse request (the 300+ line core file, the support files, etc.), then get into details of how to write your own fuse code, and how it interacts with the FB3 files. They then spend a decent amount of time with FLiP -- the Fusebox Lifecycle Process. This I found less compelling, because much of FLiP is really oriented towards contract web site development. While some is applicable to the corporate environment in which I work, other parts really don't fit all that well. Nonetheless, I feel that Peters & Papovich do a good job explaining the concepts behind FLiP, as well as the various software tools which are available now to support it. They provide quick demonstrations of wireframing & prototyping tools, a visual mind mapping tool, and a tool to build fuse-level unit testing harnesses. I found I really liked the approach of this book -- diving right into the deep end of the pool and working through the core files line by line. I'd initially gotten into Fusebox about a year ago, learning it on my own from what was available online. A few months later, I was fortunate enough to have Hal Helms teach a class in my company. And I've been developing in Fusebox almost exclusively since then. Despite this, I'd never spent much time actually working my way through the core files. In doing so through this book, I still picked up some interesting tips and tricks, and got my eyes opened on just how some of the code actually worked. In short, I think I'll build better Fusebox apps with the info I gained from this book. Now, if I can just get myself to take the time to actually write up the Fusedocs... :-)
Rating:
Summary: Great for Project Managers and Developers Alike
Review: Rather than just showing how fusebox is used, Fusebox: Developing ColdFusion Applications really concentrates more on how fusebox can be applied and helps the developer (as well as a Project Manager) to truly understand the framework. Jeff and Nat did a nice job in Part III: Fusebox Lifecycle Process showing how a development team can manage and create a project quickly and efficiently by implementing FLiP with the Fusebox framework. Overall, the book is a beneficial read for developers and project managers alike.
Rating:
Summary: Good Coverage of FuseBox 3.0, FuseDoc 2.0 and FLiP
Review: This book covers almost all aspects of FuseBox 3.0, FuseDoc 2.0 and FLiP. It covers most areas as thoroughly as possible in a single volume book. Some areas are glossed over, but, at least, they are mentioned. Several areas could have been dealt with in a little more depth, such as MVC, Prototyping, nested layouts and reusability using the CFModule tag. This book is much better, overall, than "Discovering Fusebox 3 with ColdFusion" by Hal Helms and Joh Quarto-vo Tivadar. That book fills in a few of the gaps left by Peters and Papovich's, but dealt too deeply into the "Techspedition Intranet Contact Manager" application. Peter's book does a good job of explaing the core files and making strong recommendations while still leaving room for accomodating situations out of norm. It was well written and well organized. The appendices are helpful as summarization material.
Rating:
Summary: You'll get a lot out of this book
Review: This book covers developing web applications using Fusebox and ColdFusion. However, it covers much more than the coding fundamentals. The strength of this book, aside from being an complete reference for Fusebox, is that it also covers FLiP, the Fusebox Life Cycle. What this means to you is you will not only learn how to develop Fusebox applications, but also learn a tried and true development process from concept to launch. This is an invaluable feature and I'm very happy to have this reference on my desk. Even if you choose not to read the FLiP chapters, you'll get a lot out of this book.
Rating:
Summary: Big picture to lines of code: this is a great resource
Review: This book goes from theory to nuts-and-bolts and back again on how to design, implement, use, manipulate, and manage code written in the Fusebox method. While I particularly like Wireframes and FLiP, my favorite Fusebox piece by far are FuseDocs. The book spends a fair amount of time explaining each piece of the Fusebox methodology and gives plenty of examples. There is a companion website, which is more than handy. The book is broken into two sections: coding and the life cycle of the code. Each section seems to have a bit different focus, and I imagine that the Life Cycle Process section is more immediately attractive to managers and independent developers. Yet I am glad to find both pieces here, juxtaposed. It keeps me from losing the forest for the trees in the coding section, and from getting too far removed from the actual work at hand in the FLiP section. According to the authors, Fusebox was developed for use by small teams with a theoretical manager somewhere. I can see how this methodology would bring focus to and demystify any application development. But I have to write that while teams might have been the target audience, contractors will come to love this. Fusebox and especially its FuseDoc element empower the novice contractor to tackle the Big Project that has been landed at long last and produce results without becoming overwhelmed. Far more importantly, though, it allows a developer familiar with FuseBox to speak a fluid language about time, task, and integration. As someone who finds herself after lunch looking over code written before breakfast and wondering what the heck I was trying to do, FuseDocs are a godsend. Fusebox methodology, while written for ColdFusion, isn't limited to the ColdFusion world. One could easily pick up any FuseDoc and translate it to PHP. This portability of the process renders the Fusebox methodology a staying power we haven't seen in a long time. And while extreme programming has much to recommend it, it doesn't result in a task-oriented product in the same way that Fusebox does. The Fusebox process seems to lend itself to real world applications, development and concerns in a way I haven't found in other methodologies. It also has the added bonus of becoming widely known, and could approach a standard for web-based application development. As a developer, I found the book well written as well, and one that addresses each area discretely. I personally read it form front to back, but the material seems to hold up to a piecemeal reading as well (this chapter, that section, or this reference). All this means that the Fusebox book will be kept close at hand and used often. Buy it, and don't be afraid to write in it, dog-ear it, and put flags where they make the most sense for you. I truly believe that use of the Fusebox methodology singly or by whole teams will result in programmers who get to spend more time doing what they love, and doing it in an environment they enjoy.
| 
