I recently received an inquiry from a developer about my Guru-on-Call service (www.TeamAllaire.com/hal). He requested help in identifying the fuses he would need for his application.

After reading my first two Fusebox articles in last year's CFDJ (Vol. 1, issues 3 and 4), he wrote, "I understand what you are explaining but implementing it is a little harder than I thought."

I wonder if others may be having this same problem - understanding the theory but a little hung up on the details. In this article I'm going to walk through developing a Fusebox application so you can see the theory put into reality. I'm assuming you've already read enough about the Fusebox methodology to understand how it works. If you need a refresher on this, check out the back issues of CFDJ online for the two articles I wrote with Steve Nelson and Gabe Roffman, or see the sidebar for a quick recap of Fusebox rules.

I find the hardest part of a large Web application is not the actual coding - thanks to Fusebox - but determining what the actual job requirements are. I'm not alone in this; it's a common complaint of developers. Over the years I've tried, in a variety of ways, to nail down customers so they wouldn't keep changing their minds. One day it occurred to me that the reason customers wouldn't stop making changes is because they couldn't. They couldn't tell me the "requirements" until they saw them reflected in the application.

If this is true, it's my job to make sure the users can see the application - and prod, poke and punch it - until they're sure that what they see is what they want. Only then do I begin the actual coding. I place great emphasis on a simulated application that looks like the real thing to the users. When they click buttons, things happen. Links are live. Forms accept inputs. And while it looks like a real application, it's a completely different matter under the hood. There's no database hooked up to the application. There are no persistent variables, perhaps no variables at all. Any use of code (CFML or otherwise) is there only to present a convincing simulation. We haven't begun coding yet; we're doing this because experience has shown that it's the only way to find out what kind of application we should build.

This methodology takes some of the stress off skilled programmers. In practice I find that over half the work required in developing an application can be done without involving programmers - a welcome discovery as they're hard to find. This prototype is handled by people skilled in interface design and graphical arts who create essentially static Web pages that mimic their real counterparts.

It's during this process that questions, comments and concerns surface. I needed a way to capture and contain this information in a central location where all those involved in the development of the application could communicate and contribute. Over time we've developed a method that effectively lets us define and refine what the application should be, do and look like.

This method relies on some ColdFusion code running alongside the designer's prototype work. Since designers typically aren't coders, we ask only that they save the Web files with a .cfm extension and append the following code onto each of these pages:

<cfinclude template="devnotes/index.cfm"> At runtime this code calls a small Fusebox application at the bottom of the page that produces something similar to Figure 1.

This allows us to preserve the history of the development of the application while providing a map for its continued evolution. I'm going to show you how I approached building this Fusebox-based mini-app, which I hope will make the process of creating a Fusebox application clearer than a mere reading of the rules.

I start off application development - even of small apps - by creating "use cases" to identify requirements for the application. These are natural language statements that require no technical background and are ideal for communicating between client and developer. At this point, use cases form the basis of our understanding of what the application should do. A sample use case might look like this:

"User should be able to log onto the system and be validated as either a user or administrator."

While use cases are wonderful for determining requirements for the application and for communicating with clients, they're too general to be of much use to developers. For this I rely on the skill of interface designers who understand how to translate the client's requirements into actual pages that show how they'll do it. This is the prototype I spoke of above. It's an iterative process; at each step we hopefully come closer to finding exactly what the client needs. Once all participants have agreed that the application is fully defined, we arrive at a prototype freeze. Now it's my job to match the use cases (as interpreted in the prototype) with one or more fuseactions.

Fuseactions, remember, define what the application is actively involved in; at any point there's only one fuseaction operating. A fuseaction is a request for action that's sent only to the fusebox (usually named index.cfm). It's fundamental to Fusebox that all requests for action go through the fusebox, not to individual fuses. Without this we're on a slippery slope where one fuse calls another and that fuse calls yet another until we end up with a tangled mess of intricate dependencies between fuses, defeating our goals of readability and reusability.

Once the request for action (the fuseaction) is sent to the fusebox, the fusebox calls on fuses to carry out the action. So the development process goes like this: use case ...> prototype ...> fuseaction(s) ...> fuse(s). By creating a table that shows the associations between use cases, fuses and fuseactions, I can see how complete my application architecture is. Table 1 is the table for this application.

As Dennis Miller says, "I don't want to get off on a rant here...," but let me say a word about naming fuses. The Fusebox.org site suggests naming prefixes for fuses based on the fuse's job: dsp_fusename for display-type fuses and so forth. I've heard heated debate over the "correct" naming scheme and I think this misses the key point - Fusebox is a development methodology, not a naming convention. My position is, if you find the naming scheme to be helpful, by all means use it. If you have another naming scheme - possibly already a standard within your company - then use that. The power of Fusebox doesn't depend on how a fuse is named, but on its clarity, conciseness and precision.

This method relies on some ColdFusion code running alongside the designer's prototype work. Since designers typically aren't coders, we ask only that they save the Web files with a .cfm extension and append the following code onto each of these pages:

<cfinclude template="devnotes/index.cfm">

At runtime this code calls a small Fusebox application at the bottom of the page that produces something similar to Figure 1.

This allows us to preserve the history of the development of the application while providing a map for its continued evolution. I'm going to show you how I approached building this Fusebox-based mini-app, which I hope will make the process of creating a Fusebox application clearer than a mere reading of the rules.

I start off application development - even of small apps - by creating "use cases" to identify requirements for the application. These are natural language statements that require no technical background and are ideal for communicating between client and developer. At this point, use cases form the basis of our understanding of what the application should do. A sample use case might look like this:

"User should be able to log onto the system and be validated as either a user or administrator."

While use cases are wonderful for determining requirements for the application and for communicating with clients, they're too general to be of much use to developers. For this I rely on the skill of interface designers who understand how to translate the client's requirements into actual pages that show how they'll do it. This is the prototype I spoke of above. It's an iterative process; at each step we hopefully come closer to finding exactly what the client needs. Once all participants have agreed that the application is fully defined, we arrive at a prototype freeze. Now it's my job to match the use cases (as interpreted in the prototype) with one or more fuseactions.

Fuseactions, remember, define what the application is actively involved in; at any point there's only one fuseaction operating. A fuseaction is a request for action that's sent only to the fusebox (usually named index.cfm). It's fundamental to Fusebox that all requests for action go through the fusebox, not to individual fuses. Without this we're on a slippery slope where one fuse calls another and that fuse calls yet another until we end up with a tangled mess of intricate dependencies between fuses, defeating our goals of readability and reusability.

Once the request for action (the fuseaction) is sent to the fusebox, the fusebox calls on fuses to carry out the action. So the development process goes like this: use case ...> prototype ...> fuseaction(s) ...> fuse(s). By creating a table that shows the associations between use cases, fuses and fuseactions, I can see how complete my application architecture is. Table 1 is the table for this application.

As Dennis Miller says, "I don't want to get off on a rant here...," but let me say a word about naming fuses. The Fusebox.org site suggests naming prefixes for fuses based on the fuse's job: dsp_fusename for display-type fuses and so forth. I've heard heated debate over the "correct" naming scheme and I think this misses the key point - Fusebox is a development methodology, not a naming convention. My position is, if you find the naming scheme to be helpful, by all means use it. If you have another naming scheme - possibly already a standard within your company - then use that. The power of Fusebox doesn't depend on how a fuse is named, but on its clarity, conciseness and precision.