You are previewing Fusebox: Developing ColdFusion® Applications.
O'Reilly logo
Fusebox: Developing ColdFusion® Applications

Book Description

Developers face a constant struggle to launch projects on time and under budget, especially without pulling all-nighters. Fusebox helps ensure successful projects by providing a framework that serves as a base for applications. It's a standard process that makes projects more manageable and simplifies maintenance and requests for change during development. With this book, you'll learn to make ColdFusion applications reliably successful by following a standardized system. In addition, relying on the Fusebox framework to help plan and organize your ColdFusion code will allow you to write increasingly complex and specialized applications.

Jeff Peters and Nat Papovich, both members of the Fusebox Council, share their extensive experience in this book. They'll teach you to use Fusebox with your ColdFusion applications and develop a set of best practices for managing web projects. Read this book if you want to eliminate frustrations and roadblocks in your projects, such as unmanageable complexity, wasteful redundancy of effort, time-consuming code maintenance, and slow development speed.

Table of Contents

  1. Copyright
  2. About the Authors
  3. About the Technical Reviewers
  4. Acknowledgments
  5. Tell Us What You Think
  6. Foreword
  7. Introduction
  8. Fusebox Basics
    1. The Arrival of Fusebox
      1. What Is Fusebox?
      2. Basic Fusebox Concepts
      3. Technical Fusebox Principles
      4. That Was Fusebox
    2. Is Fusebox Right for You?
      1. Fusebox and Other Methodologies
      2. Speed of Development
      3. Simplicity
      4. Maintainability
      5. Fusebox Is Proven
      6. Extensibility
      7. What Kinds of Applications Can I Build?
      8. How to Decide if Fusebox Is Right for You
  9. Fusebox Coding
    1. The Fusebox Framework
      1. Notes About the Framework Files
      2. Starting the Request
      3. Notes on the Core File
      4. The Very Top of the Core
      5. Section 1: The Fusedoc
      6. Section 2: The API
      7. Section 3: The FB_ Structure
      8. Section 4: for mURL2attributes
      9. Section 5: fbx_circuits.cfm
      10. Section 6: Reverse Circuit Structure
      11. Halfway Through the Core
    2. Handling a Fuseaction
      1. Section 7: Root fbx_settings.cfm
      2. Section 8: Preparing the Fuseaction
      3. Section 9: Children fbx_settings.cfm
      4. Section 10: Target fbx_switch.cfm
      5. Section 11: fbx_layouts.cfm and Layout Files
      6. Finishing the Processing
      7. It’s All Under the Hood
    3. The Fuses
      1. The 10 Fuse Rules
      2. Fuse Examples
      3. That’s It for Fuses
    4. Exit Fuseactions
      1. What Are XFAs?
      2. Implementing XFAs
      3. Why Use XFAs?
      4. Filling the Toolbox
    5. Fusedocs
      1. The Essence of Fusedoc
      2. Elements of Fusedoc
      3. IO Element
      4. Tools for Fusedoc
      5. Fusedoc in Applications
      6. Wrapping Up
    6. Nesting Circuits
      1. The Power of Nesting
      2. Understanding the Application’s Structure
      3. Nesting and Inheritance
      4. Performance Considerations
      5. Nested Circuits Allow Nested Layouts
    7. Nested Layouts
      1. Why Nested Layouts Work
      2. fbx_Layouts.cfm and Layout Files
      3. Designing for Layout
      4. Fusebox with Different Layout Goals
      5. Bringing Nested Layouts Home to Roost
    8. Nested Coding Concepts
      1. Relativity
      2. Placing Code in a Fusebox Application
      3. UDF Positioning
      4. A Place for Everything
  10. Fusebox Lifecycle Process (FLiP)
    1. Introduction to Development Methodologies and FLiP
      1. Methods and Methodologies
      2. Planning
      3. FLiP
      4. FLiP for Better Applications
    2. Wireframing
      1. What Is a Wireframe?
      2. What Is Involved in Wireframing?
      3. Wireframing Tools
      4. Wireframing in Action
      5. Site Map
      6. More Wireframe Pages
      7. It’s That Easy
      8. More Wireframe Pages
      9. Closing Thoughts
    3. Prototyping and DevNotes
      1. Introducing Prototypes
      2. Creating a Prototype
      3. DevNotes
      4. Prototype and Get It Right
      5. Prototype Considerations
      6. Put It All Together
    4. Construction and Coding
      1. Identifying Exit Points
      2. Grouping Fuseactions
      3. Another Kind of Group: Wizards
      4. Identifying Circuits
      5. Mind Mapping/Fuseminder
      6. Analyzing Fuseaction Steps
      7. Labeling Fuses
      8. Fuseminder2: Just Like Magic
      9. Create Fusestubs with Fusedocs
      10. Distributing Code to Developers
      11. A Job Well Done
    5. Unit Testing
      1. Thinking About Testing
      2. Units and Test Harnesses
      3. The Process of Unit Testing
      4. All Tests Completed, Houston
    6. Application Integration and Deployment
      1. Integration
      2. Deployment
      3. Signoff
      4. We Have Lift-Off
    7. Best Practices
      1. Security and Fusebox
      2. SES URLs
      3. Encrypted URLs
      4. Fusebox and Frames
      5. Popular Custom Tags
      6. Learn from Exper ience
    8. Fusebox Exotica
      1. PHP Fusebox
      2. Fusebox and Java (J2EE Fusebox)
      3. What a Ride!
    9. The Adventure Continues
      1. Shootin’ Hoops
      2. Some Final Words
  11. Appendixes
    1. Fusebox 3.0 Specification Reference
      1. The Framework Files
      2. Fuse Rules
      3. Fuse Types
      4. Exit Fuseactions
      5. Fusedocs
      6. Nested Circuits
      7. Nested Layouts
    2. Fusebox Glossary
      1. Glossary
    3. Fusedoc Data Type Definition
    4. Fusebox Version 2 to Version 3 Comparison
      1. Two New Features of Fusebox 3
      2. Version 2 and Version 3 Framework Files
      3. A Code Comparison of FB2 and FB3
      4. Updating Your Skills and Applications
    5. Fusebox Resources
      1. Council Sites
      2. Community Sites
      3. Commercial Sites
      4. You Be the Resource