Everyone is excited about ColdFusion 8; the blogs have been buzzing, feedback has been superb, lots of attendees expressed relief and gratitude at seeing such a compelling ColdFusion built in this new Adobe era - no complaints, no negative feedback, just real enthusiasm and excitement. The only frequently heard complaint was from users who want it now!

The next major version of ColdFusion, code-named 'Blackstone,' is getting ready to ship, and by gauging customer and partner reactions thus far, we have a winner on our hands.

MAX 2004 easily ranked as one of our best conferences ever. Between product announcements, the sessions, increased attendance, and the New Orleans scene, it set a new standard for us to beat next year.

This column started life as a series of e-mail threads that then morphed into blog postings at www.forta.com/blog. As these points are important and need to be articulated frequently, I morphed them yet again into a column. Enjoy.

In my last column we looked at using ColdFusion Components to abstract database access, essentially divorcing presentation code from anything database specific. As you will recall, the benefit of this was that when a database change occurred (a column being renamed, for example), presentation code was not impacted at all. In this column I'II take this concept one step further.

I've been discussing ColdFusion Components on and off since we first introduced them - which was in ColdFusion MX - and even dedicated my entire keynote time slot at our 2002 conference to CFCs, as well as covering them extensively in prior CFDJ columns. But, apparently, many users have yet to take advantage of these important application building blocks, or have failed to fully appreciate their necessity.

Macromedia Flex is a brand new server product, one that is poised to forever change the way we coders think about building rich and engaging user interfaces. Yes, I did say 'server.' No, Flex does not compete with ColdFusion. Yes, Flex and ColdFusion are designed to work together.

Way back in the early Allaire days, registered ColdFusion users were given access to 'fuel packs', product add-ons (in the form of custom tags) that may or may not have become part of the core product later. In fact, tags like , , and all started life as fuel packs, and later became part of the core ColdFusion product.

Conventional wisdom dictates that code, all code, be written with portability in mind. After all, you wouldn't want to have to revisit and rewrite code when moving between platforms or environments, would you? And while I do believe that coding for portability is a good thing in general, I also believe that when it comes to databases and SQL, coding for portability is a very bad thing indeed.

Uttering the dreaded 'D' word in front of a room of hard-core ColdFusion developers is a brave act indeed. Hating Dreamweaver and berating its deficiencies has become a popular pastime among ColdFusion purists, so what I'm about to say may get me in all sorts of trouble.

It's been about seven years since I first inscribed my '10 Commandments of ColdFusion Development' for my first ColdFusion book, and four years since they were last revised (yes, my Ten Commandments are not as omnipresent as their more famous namesake). ColdFusion has changed much over this time, as have the applications we're building and how we build them.

ColdFusion developers rely on session state management and the SESSION scope extensively. But as applications grow in complexity, so do the number of SESSION variables, and the risk of overwriting or misusing them.

One of the most used tags in CFML is . It is definitely the most used of all the Internet protocol tags, and as one of the original CFML tags (it was actually one of the DBML tags and originally named ), it has also been slowly enhanced and updated with each new release of ColdFusion. Slowly. Maybe a little too slowly.

It's been over a year since Macromedia released the most important and ambitious ColdFusion ever, ColdFusion MX. Considering the scope of the undertaking, ColdFusion MX has been an incredible success.

By now, every ColdFusion developer knows, or should know, that ColdFusion MX sits on top of underlying Java architecture. Some ColdFusion developers have even been brave enough to attempt ColdFusion/Java integration, creating applications that leverage Java code where appropriate.

Most Web-based applications operate in real time. Add an article to a database and it shows up immediately on content pages. Update a user address and the new contact information is available immediately. Add or remove an employee and the phone directory is correct when next viewed. Real-time data in a real-time world. That's a good thing, isn't it?

I receive lots of e-mail from lots of ColdFusion developers, and make every effort to respond to each and every one of them. Knowing the problems that ColdFusion developers are attempting to solve helps me know what topics to write and speak about. Indeed, the inspiration for most of my CFDJ columns comes from questions and comments from readers. So when I received two e-mails in one week asking about how to handle database locks when locks can't be used, well, the result is the column you are reading.

Several months ago I wrote a column entitled 'Undocumented ColdFusion MX - 1,' (CFDJ, Vol. 4, issue 9). I appended a '1' to the title in anticipation of there being a '2' at some later date. Well, that time has come. That column (which apparently was highly controversial and upset quite a few readers, but fortunately made even more happy) exposed and explained the use of the ColdFusion factory object. This time we'll look at some of the configuration files used by ColdFusion MX - files that can be tweaked as needed (and no controversy this time, I think).

ColdFusion MX is fast approaching its first birthday, and what a first year this has been. A completely brand new ColdFusion, incredible new features and technologies, and even versions that run on J2EE servers on all sorts of platforms (including the oft requested Mac OSX). Which makes this a great time to review the ColdFusion-Java relationship, and what it means for you.

Which is faster, or ? Which is faster, CFML or ? Which is faster... ? If you're a ColdFusion developer, chances are that you've asked (or have been asked) these questions and others like them.

There is a phenomenon that appears to be unique to our industry - something I call buzzword du jour. On a regular basis a new buzzword (usually accompanied by a series of acronyms) appears on the front pages of the trade rags proclaiming to be 'the future' - the message being 'jump on board or become obsolete.' This happens so frequently that many of us are becoming immune to it all, and in doing so are running the risk of missing something important when (or if) it happens. Which brings us to Web services.

There was once a time, not that long ago, when I seemed to be spending a significant portion of my life explaining why ColdFusion was indeed worthy of consideration even though other products were free. Then I stopped hearing that objection for the most part, and life was good (well, better).

HTML-based data entry is a pain, both for developers and for end users. There's no way to sugarcoat it, HTML forms as used today are pathetic. Sure, there are new form specifications on the way, but they are not yet in use, browsers don't support them, and they are still unproven entities. Luckily, there's an option available right now; it's called Macromedia Flash MX.

I have been writing and talking about ColdFusion components since before ColdFusion MX shipped. After I explained them in detail in two recent columns (CFDJ, Vol. 4, issues 6, 7), quite a few of you asked for practical examples of when and where they should be used. So, once again, let's take a look at CFCs, but this time from a very different angle.

Discovering undocumented features in your favorite application is always something of a thrill. This is especially true when those features expose little nuggets of functionality that you can leverage in your own code. And so, as promised in my last column, I'm going to introduce you to the factory, a set of internal ColdFusion MX services exposed via Java objects and APIs.

The introduction of user-defined functions (UDFs for short) was the most requested and anticipated event in the ColdFusion 5 era - developers desperately wanted to be able to extend CFML, using not just tags, but functions as well. I first introduced UDFs a year or so ago (CFDJ, Vol. 3, issue 5), but now it's time to revisit the subject. Why? Because ColdFusion MX provides us with a whole new way to write UDFs, this time using tags.

Last month I introduced you to ColdFusion Components - CFCs for short. Following a brief introduction to the world of objects, we looked at CFCs and their syntax, and simple calling conventions using . This month we'll continue this topic.

In the May issue of CFDJ (Vol. 4, issue 5) I introduced you to ColdFusion MX - the just-released ColdFusion upgrade that is nothing short of revolutionary. As I explained in that article, CFMX features lots of incredible new technologies and features. But the one I think is most important (in terms of how it will, or should, impact your development) has to be ColdFusion Components. This month (and continued next month) I'd like to explain in depth what CFCs are and how they should be used.

Have you ever seen a ColdFusion error page - the bordered box on a white background that basically says someone (or something) messed up? I'm sure you have, as I'm sure your users have too. Errors, and error messages, are an unfortunate fact of development life. But while you may have to live with occasional errors, you definitely do not (and should not) have to live with that too-oft-seen CF error screen.

Databases and database access are fundamental elements of just about every ColdFusion application ever created. Database access makes applications real and live and dynamic and valuable, but it's also a major source of performance problems and a primary potential security target. In this article I discuss an oft overlooked tag, , designed to help address both potential problems.

Barely a week goes by without someone asking me about ColdFusion and search engine-friendly URLs. This is one of those topics that ColdFusion developers have been discussing for a long time - I first started a thread on this subject on the Allaire Developer's Forum close to five years ago. As this topic keeps coming up (and because three of you e-mailed me to ask about it this morning), I decided to scrap the column I was writing in favor of an explanation of all this once and for all.

With all the talk and buzz surrounding Neo, it's important to keep in mind that ColdFusion 5 is still a relatively new product, one that many users have yet to take full advantage of. We're proud of ColdFusion 5, and rightfully so. It's the most reliable, most scalable, and most powerful ColdFusion yet, as well as the fastest server we've ever created. It's simply the best ColdFusion to date.

At last month's Developers' Conference in Orlando I was fortunate to be one of the first to demonstrate Neo, the next major version of ColdFusion. Macromedia (and earlier, Allaire) had been dropping little Neo-related tidbits for quite a while now - whetting our appetites with glimpses of what is to come. But as those of you who were in Orlando now know, Neo is exceeding all expectations.

ColdFusion 5 is a great product, so much so that I've dedicated six of my last seven columns to introducing and analyzing its new features and technologies. ColdFusion 5 is mature, fast, reliable, and robust, and with its release Macromedia has demonstrated a definite commitment to CF and the former Allaire community. And the community acknowledges this.

For ColdFusion to work properly lots of bits and pieces have to be in place and functioning correctly. Web servers need to be up and running, database servers need to be accessible, any external components need to be reachable, and, of course, ColdFusion must be functioning properly. If any of these fail, so will your applications; if failure does occur, you need to know as quickly as possible, preferably before end users find out. Which brings us to the subject of probes.

At last year's Developer's Confer-ence I presented a session on creating n-tier (or multitier) applications in ColdFusion, explaining how tiered applications were more manageable and reusable. So why bring this up almost a year later? Well, a project I was working on recently forced me to revisit this topic, but this time for a whole new reason.

I hope that all of you are enjoying your summer and getting in plenty of R&R. If you aren't, I hope you have at least upgraded to the new CF Server 5.0.

With the recent merger of Allaire and Macromedia - the combined concern now called Macromedia - developers should be excited about all the new ways ColdFusion development technologies can be used with Flash interface technologies.

More ColdFusion applications are running on intranets and extranets than just about anywhere else. This is not surprising - as ColdFusion makes data access and reporting so simple it is a natural fit for applications in these environments. And, as such, data reporting is one area that ColdFusion 5 addresses head-on with the introduction of a true graphing engine.

This month I'd like to continue exploring ColdFusion 5 - this time concentrating on a radical new feature known as Query of Queries - a feature that lets you treat query results as if they were database tables. Intrigued? Read on.