I've been busy experimenting with the ColdFusion 8 beta release from Adobe and let me assure you the software is going to have a huge impact on the RIA (rich internet application) universe and on Web application development in general. It's going to open up a world of new possibilities for every class of developer, from beginner to intermediate to master, while at the same time providing major enhancements to existing tags and features. In this article I'm going to highlight what I feel are two of ColdFusion 8's most exciting and compelling new features: AJAX components and the <CFFEED> tag. I hope that after reading this article you'll share my enthusiasm and optimism and will be looking forward to the official release of ColdFusion 8 as much as I am.
You Know It Don't Come Easy
AJAX stands for Asynchronous JavaScript and XML. It's a complex combination of HTML, CSS, JavaScript, and XML code that produces interactive and highly responsive interfaces for Web applications. If you've ever used Google Suggest in which a list of suggested search terms is displayed as you enter characters into a search box, then you've seen AJAX in action. The improved interactivity, responsiveness, and sophistication of AJAX interfaces are, in a word, remarkable. However, writing the necessary server and client-side code to make such sophisticated user interfaces possible is a difficult and time-consuming challenge, and that's putting it mildly. In fact, it's probably safe to say that only a small fraction of highly skilled developers is capable of creating an AJAX interface from scratch. However, all of this is about to change, at least for ColdFusion developers, because ColdFusion 8 will provide built-in tag-based support for AJAX components. Let me say that again: ColdFusion 8 will provide built-in tag-based support for AJAX components. This means that ColdFusion developers will be able to implement AJAX features in their applications using the CFML that we already know and love. This is very good news for those of us who don't relish the prospect of becoming intimately familiar with JavaScript, DHTML, and XML programming. For purposes of this article, the term "AJAX component" means a combination of ColdFusion tags and other markup needed to implement a specific AJAX user interface (UI). Don't confuse this term with ColdFusion components (CFCs), which enable developers to encapsulate data and business logic in separate, easily maintainable, and reusable files that have a .cfc extension.
Recently Ben Forta, Adobe's senior product evangelist for ColdFusion, posted a series of ColdFusion 8 AJAX tutorials on his Web site at www.forta.com/blog. The tutorials provide code examples and basic information on how to implement five different ColdFusion 8 AJAX components: Auto-Suggest, Live Data Grids, Partial Page Updates, Related Selects, and File System Tree Control. If you're interested in getting up to speed quickly on the AJAX features in ColdFusion 8, Ben's site is a great place to start.
After reviewing the five AJAX examples on Ben's site, I decided that my favorite (for now) is Auto-Suggest. This AJAX component augments the standard <CFINPUT> tag by adding a new auto-suggest attribute. The auto-suggest attribute accepts a comma-delimited list of values and can be populated using a database query, hard-coded values, or a CFC. In the latter case the rendered page uses ColdFusion-generated JavaScript to make asynchronous calls to a CFC that retrieves data from a database. The data is returned to the <CFINPUT> tag, which the auto-suggest attribute uses to display a list of suggested search terms. Regardless of the method used to populate the auto-suggest attribute, ColdFusion automatically generates the necessary JavaScript, CSS, and HTML code behind the scenes so that developers don't have to do it.
Of course, since this is ColdFusion I expected nothing less than this, i.e., powerful AJAX functionality combined with the simplicity of a tag-based language, and that's exactly what the Auto-Suggest AJAX component delivers. The code in Listing 1 is a simple example in which the auto-suggest attribute of the <CFINPUT> tag has been populated with hard-coded values. If you're running ColdFusion 8 yourself and want to get a firsthand look at this feature, you should be able to copy and paste the code from Listing 1 and save it as a new ColdFusion file. Figure 1 shows the suggested search terms displayed by the auto-suggest attribute as text is entered into the control.
Long Live the Grid
The Live Data Grid, a k a the HTML data grid, is an equally compelling AJAX component in ColdFusion 8 because it can substitute for cumbersome HTML tables, can be customized, and has built-in support for record paging. Dropping an HTML data grid into your application means you'll have a convenient place to deposit data for display in your application. The HTML data grid can be "pre-populated" with data or it can load data as needed by invoking a CFC that executes a database query to retrieve data asynchronously.
In either case the resulting data grid is resizable and the colors, fonts, etc. are all customizable. A user can sort the records displayed in the grid simply by clicking on a grid column header. The HTML data grid seems like a solid alternative to ColdFusion's existing Flash and Java applet-based data grids. I found it handy because it's easy to simply drop the grid into a template and load it up with data from a query. This is a good way to rapidly prototype an application because you'll have something to show users almost immediately, without having to spend a lot of time and effort coding the UI.
For the first time, ColdFusion developers will be able to implement AJAX functionality in their applications without having to write a lot of messy and tedious JavaScript, XML, and CSS code. For beginners and less experienced developers the new AJAX components can be readily deployed in applications using familiar ColdFusion tags. This means that they won't need to possess advanced knowledge of JavaScript, XML, and CSS to make AJAX work. In fact, with ColdFusion 8 it's possible to produce some stunning AJAX-type effects in ColdFusion applications with only minimal time and effort and relatively little code.
Of course, Flash forms and Flex are still available to developers in ColdFusion 8. It's just that now we have a choice between these UI solutions and AJAX. ColdFusion developers will be able to choose between a Flash-based and AJAX-based solution for their applications. This is good news because there will undoubtedly be occasions when one approach is more suitable than the other. For example, the use of AJAX on a Web site may be prohibited due to accessibility concerns, so the developer could simply go with a Flash-based solution like Flex or Flash forms which tend to be more accessible-friendly than AJAX. On the other hand, if for some reason Flash is prohibited on a company intranet then the developer could use AJAX. With ColdFusion 8's AJAX components, developers will have yet another solid UI choice for their rich applications that can be implemented both quickly and easily.
News Flash: All You Need Is CFFEED
Another exciting new feature in ColdFusion 8, and one that I've been playing around with extensively, is the <CFFEED> tag. <CFFEED> is a powerful new tag that will let developers generate and consume RSS (Really Simple Syndication) and Atom news feeds in their ColdFusion applications. RSS is an XML-based format for sharing and distributing Web content, such as news headlines. The <CFFEED> tag will let developers easily integrate RSS news feeds into their applications, generate their own feeds, or build entire applications around news feeds. ColdFusion 8's <CFFEED> tag is best demonstrated with an example. Like the AJAX components in ColdFusion 8, the <CFFEED> tag is straightforward to use. Figure 2 shows a basic application that uses the <CFFEED> tag to retrieve a news feed and a simple HTML data grid to display it. Each row in the data grid serves as a link to the full news release available on EPA's Web site. The code behind this application is shown in Listing 2.
In Listing 2 the <CFFEED> tag is used to read EPA's "Air News Releases," an RSS 2.0 news feed that is then displayed in a simple ColdFusion 8 HTML data grid. A list of EPA news feeds is available at www.epa.gov/newsroom/rssfeeds.htm. Like most RSS feeds, EPA news feeds are comprised of XML or eXtensible Markup Language. XML is markup that contains and describes data. The EPA news feed XML is "consumed" by the <CFFEED> tag and converted into a ColdFusion query that can then be used just like any other ColdFusion query. This is significant because once you've used <CFFEED> to grab an RSS feed, you can do anything you want with the query result.
For example, if you were interested in only a subset of the data retrieved by <CFFEED> you could query it again using ColdFusion's Query of Queries (QoQ) feature. This is precisely what I did in the example. After retrieving the EPA news feed with <CFFEED>, I queried the resulting query (using QoQ) and extracted just the records that I was interested in, i.e., records having EPA in the title. Remember how I said earlier that ColdFusion 8's HTML data grid provides a convenient destination for query data that you want to display? In this example the final filtered record set that I named "getFilteredRSS" is easily displayed in a simple ColdFusion 8 HTML data grid.
When building RSS applications in earlier versions of ColdFusion you had to perform the XML to query conversion manually, i.e., in CFML code, which usually meant writing dozens if not hundreds of lines of code to parse the XML, extract the desired data, and then convert it into something useful like a query result. Of course, in ColdFusion MX applications the developer could have used one of the freely available CFCs written for this purpose.
My favorite news feed CFC is (or was) Ray Camden's "rss.cfc," which can be found at http://cfrss.riaforge.org/. However, even this CFC consists of hundreds of lines of CFML code. I prefer having this functionality in a single ColdFusion tag because the implementation is a lot cleaner and simpler (sorry, Ray!). I think that the presence of the <CFFEED> tag in ColdFusion 8 will encourage novice developers to start building applications that consume, generate, or otherwise incorporate news feeds.
The <CFFEED> tag is clearly an important and powerful addition to the ColdFusion tag arsenal and ColdFusion 8 should give a tremendous boost to developers who want to work with news feeds in their applications. In my opinion, the <CFFEED> tag is right up there with other powerful and versatile ColdFusion tags such as <CFHTTP>, <CFFILE>, and <CFFTP>. It offers tremendous functionality in a single tag that would otherwise require many lines of code. The best things really do come in small packages, don't you think?
Accidents Will Happen
I want to mention two
ColdFusion diagnostic tools that greatly facilitated my exploration of
ColdFusion 8. The first was the good old <CFDUMP> tag. It has
always been there when I needed it and, boy, did I need it this time. I
knew that the <CFFEED> tag returned a query, but I didn't know
what the column names would be or which columns contained the data I
needed. Without this crucial information it would have been impossible
for me to use the <CFFEED> tag at all. This is where
<CFDUMP> came to the rescue. I used it to inspect the query that
was being returned by the <CFFEED> tag. Once I did this, I found
the columns with the data I was interested in: "Title," "Rsslink," and
"Publisheddate." With this information in hand, it was then a simple
matter to write the necessary code to display the news feed query data
in a Web page or even better in an HTML data grid (as shown in Listing
2). The syntax of <CFDUMP> is simple:
<CFDUMP VAR="#myQuery#">
When ColdFusion encounters this code it displays or dumps the entire contents of the "myQuery" variable, including all query rows and columns, in a neatly formatted table. <CFDUMP> is absolutely indispensable when building and troubleshooting ColdFusion applications and, as I discovered, when checking out new ColdFusion tags like <CFFEED>.
The other diagnostic tool I used while exploring the many features of ColdFusion 8 is available only in ColdFusion 8. This is the AJAX debugger that's a window that displays diagnostic information on the status of ColdFusion 8 AJAX components. To make the AJAX debugger window appear, you'll need to enable this option in the ColdFusion 8 Administrator (in the Debug Output Settings page in the Administrator select "Enable AJAX Debug Log Window"). You'll also have to add the "cfdebug" flag as a URL parameter when viewing your page in a browser like this:
http://127.0.0.1/CF8/myAutoSuggestExample.cfm?cfdebug
Once you've done this, ColdFusion 8's AJAX debugger should appear and provide you with detailed real-time information about the status of your code. The diagnostic information includes error descriptions, debugging information, and feedback on what the AJAX component is doing at any given moment. While experimenting with Auto-Suggest, I noticed that the debugger was displaying real-time information about every CFC invocation made by the AJAX component and listing the values of all data being returned by the CFC. This is extremely useful information to have on hand if you're troubleshooting a problem, or even if you're just trying to learn the basics of how AJAX components function in ColdFusion 8.
Conclusion I'm very impressed with ColdFusion 8 because it will greatly simplify difficult time-consuming programming tasks and make them less intimidating and more approachable for developers, especially beginners. With ColdFusion 8 it appears that AJAX will no longer be the exclusive realm of the coding masters. Mere mortals like me will be able to leverage AJAX components to build sophisticated user interfaces quickly and with relatively little effort. The AJAX components are built right into the language and are readily available via tags. All we developers have to do is use the right tags and attributes in our code, and ColdFusion will take care of the rest.
As I've always said, ColdFusion excels at making even complex tasks seem easy, and ColdFusion 8 is no exception. As a developer, the prospect of being able to drop advanced AJAX functionality, RSS feeds, and who knows what else into my ColdFusion applications using good old CFML is very exciting. I can hardly wait to see the look on my users' faces when they type a search term into one of my ColdFusion forms and a list of suggestions magically appears!
When this was written, Adobe hadn't released ColdFusion 8 yet. However, I find myself contemplating all of the cool new features and how I might integrate them into my ColdFusion applications. So, I'm going to wrap up this article with a plea to Adobe: for heaven's sake, please don't make us wait much longer for ColdFusion 8. We need AJAX (and <CFFEED>) now!
Disclaimer: The views expressed in this article are those of the author and do not necessarily reflect the views or policies of the U.S. Environmental Protection Agency (EPA).