One of the biggest problems developers face everyday is moving a project along and producing solid code without cutting corners. This typically means a lot of copying, pasting, searching and replacing, and a whole lot of manual editing. At every point the potential for error increases. Confidence in your code diminishes and your day gets longer.

Now, to add to the joy, consider this: change.

Change is inevitable and becomes another item for developers to manage throughout the development lifecycle. Change comes in the form of scope creep, modified business requirements, database schema changes, functionality enhancements, etc. Now change can be good, however at the end of the day these changes can have a big impact on the cost, timelines, and ultimately the success of your project.

A project, like a house, requires a strong foundation; the stronger the foundation, the more confidence you have that the structure will withstand the pressures put on it. The same applies to a project. The stronger the foundation code, the more reliable the rest of the application built on it will be.

So, how do we as developers deal with change efficiently and effectively? It's not uncommon for code to be scrapped as changes are incorporated. You spend a great deal of time developing component models to abstract yourself and your project from change, but at some point, when the database schema changes you find yourself editing that code again and you'll ask yourself, "How many times have I had to go back through this code and make modifications to accommodate database changes?"

Introducing cfcPowerTools
The idea of creating data access layers (DAL) is pretty common for a number of other programming languages such as ASP.NET and Java. Newer is the idea of creating code via an object-relation mapping tool and while tools like Hibernate and LLBLGen, which are quickly becoming more common for Java and .NET. But ORM tools aren't quite there yet on the ColdFusion scene.

Until now cfcPowerTools has been a productivity tool for generating consistent, predictable, and repeatable (CPR) code. It lets developers quickly and accurately generate ColdFusion components (CFCs) and supporting templates (html/xml/flash forms, lists) in a fraction of the time it would take to hand-code.

CFC Types
ColdFusion provides developers with a powerful set of tools to create components and Web Services and implement these objects in a wide range of frameworks and methodologies. While CF provides all of this flexibility and power the one thing it doesn't provide is the capability to quickly and easily generate the code you need for the approach or methodology you choose to work in. cfcPowerTools is methodology-agnostic and generates ColdFusion components (CFCs) using generation templates (called CFC Types). Better still you can create your own CFC Types, or modify the existing ones to meet your needs.

CFC Types include (see Figure 1).

• Model Controller is composed of two CFCs: a primary cfc that houses all property tags and a model cfc that manages interactions with the database.
• MachII generates CFCs supporting the MachII framework. The primary cfc for the MachII cfc type is the DAO cfc. The DAO is responsible for persisting data. The DAO CFC will retrieve data from a database and return a bean cfc. The bean contains all cfproperty tags. The bean has no knowledge of the DAO. The DAO contains all of the CRUD functionality.
• Concrete is designed to extend another CFC file. The concrete CFC Type works really well with the model controller CFC type. A good technique is to use a model controller CFC Type to generate your "abstract" CFC. This abstract CFC contains all of your property definitions plus data persistence code generated by cfcPowerTools. Use a concrete CFC Type to produce a CFC that extends the abstract. You put all of your business logic in your concrete CFC. You can now manage change by regenerating your abstract CFCs, keeping your business logic separate.
• Simple is used as a teaching tool for learning how to create a CFC Type.
• CRUD generates a single CFC file that contains all properties and CRUD (Create, Read, Update, and Delete) methods.

User Interface
When was the last time you took a look at the Component Doc tool in CFAdmin? Probably never, right?

The Component Doc view lets a user see the metadata about a CFC as well as the information about the properties and methods available in a component; it's a read-only tool.

cfcPowerTools utilizes Component Doc view, but makes it really useful: you can add, edit, and delete properties, add methods, as well as toggle between a method's metadata and the actual <cffunction> code (see Figure 2). By leveraging a known user interface and by adding real functionality to it that allows a developer to get the most out of their time, cfcPowerTools brings a whole new take on working with components in ColdFusion.

Code Behind
Code behind is the process of reading the actual <cffunction> code into a UI. You can toggle between the metadata view of Component Doc and the actual <cffunction> code (see Figure 3). It's real-time, so as you make changes, those changes will get pulled into the UI the next time you toggle the function.

Productivity We all need to be productive. When was the last time you got paid for producing nothing? cfcPowerTools is focused on making you more productive. Its purpose in life is to get a lot of the grunt work code generated, to get you past writing all of the CRUD code, getters and setters, and properties. You can focus on business requirements faster. An added benefit is you start off with a solid code foundation.

Here is an example of generated Getter/Setter code:

<cffunction access="public" name="getCustomerID" returnType="string" output="FALSE">
    <cfreturn variables.instance.CustomerID>
</cffunction>
<cffunction access="public" name="setCustomerID" output="FALSE">
    <cfargument name="CustomerID" type="string" required="1"/>
    <cfset variables.instance.CustomerID = arguments.CustomerID>
</cffunction>

Initial test results generated around 14,000 lines of code supporting 22 database tables in about five minutes. Because code is generated from templates, you can control the quality of the code produced and can rest assured that the code will be consistent, predictable, and repeatable.

Manage Change
Change happens. It can be viewed as job security or as a hassle that we have to get through. Either way, it's inevitable. So, how does cfcPowerTools mitigate change?

Wouldn't it be nice if we were notified when our code was out of synch with our database structure? cfcPowerTools analyzes and compares your CFC with its underlying table and warns you when the two are out of synch (see Figure 4). With a click of a button you can synchronize the properties with the fields or vice versa.

Having properties and fields out of synch means your CRUD statements are out of synch as well. Bad things can happen. Not to worry, since all CRUD statements are within managed code blocks, you can regenerate your CFCs and the CRUD statements will be updated to account for the synchronization.