If you were to analyze all the timings and debug output from your ColdFusion applications, you'd undoubtedly find that more time is spent processing <CFQUERY> tags than anything else (possibly even everything else combined). In other words, eliminate all your <CFQUERY> tags and your application will fly. And while avoiding databases is not at all practical (or even advisable), understanding the price of real-time data interaction is important.

Of course, database access and <CFQUERY> are not the only culprits; you likely use Web services and CFX tags and calls to COM and Java and more, and all of those can impact performance too. But databases are a good place to start because they're so prevalent and because making changes (where appropriate) is actually not that difficult.

Is Real Time Really Necessary?
Obviously, some applications (or parts thereof) must be real time. Could you imagine eBay auctions if bids were updated only periodically? How do you think users would react to Amazon.com listing products as in stock only to send out an "oops" e-mail after checkout? What would users do if they changed their AOL or Yahoo or MSN passwords only to find that the password change took some unknown length of time to take effect? All of these sites utilize real-time processing to ensure the best customer experience - some operations simply must occur in real time.

And that's key - some operations, but not all. If you were to place an online classified listing on any of the major classified sites (including Yahoo) you'd find that your ad did not appear instantaneously. Rather, listings are updated with current information at regular intervals. Similarly, online user directories obtain new data on a regular basis, but online listings sometimes take months to be updated.

So why are some operations performed in real time and others not? Simply because there is a tradeoff to be made - the more data is real time, the greater the hit on performance and scalability. As such, developers of applications have to choose between the two, and for many, the choice is to not perform real-time processing unless it is absolutely required.

But most ColdFusion developers don't make the choice at all. ColdFusion makes implementing real-time processing so easy (much easier than implementing anything non-real time) that they go the real-time route by default. That's a real problem.

Reducing Database Reads
I'm not going to be able to cover every real-time scenario in this column, but I would like to point out some ideas you should think about as a starting point. The simplest (and remarkably effective) change you can make to your application involves the reading of data from database tables. <CFQUERY> is a very powerful tag; it lets you access all sorts of databases easily, maybe too easily. And so developers tend to overuse <CFQUERY>, often rereading data that likely has not changed (or has changed with changes that need not be utilized immediately).

I covered reducing database access via caching extensively in a column entitled "Caching in on Performance" (CFDJ, Vol. 1, issue 2). As explained there:

Where would you use caching within your applications? Here are some examples:

Even though frequently retrieved data is likely cached by the database server itself, retrieving the data again is obviously more resource intensive than not requesting it at all. Furthermore, as ColdFusion usually isn't running on the same box as the database server, eliminating unnecessary database requests can also reduce network traffic between the two machines, which in turn further eliminates potential performance bottlenecks.

ColdFusion provides two different ways to cache database reads:

I am not going to explain these here; refer to the previously mentioned column to learn more.

Reducing Dynamic Processing
Beyond database access, you likely have entire blocks of your application that are being generated programmatically in real time, but that perhaps need not be. For example, the above mentioned employee list. Not hitting the database unnecessarily is a great first step, but you also loop through the results creating output and embedding formatting. Does that really need to occur on each and every page request?

ColdFusion provides several options that may be used to reduce dynamic processing, and you may use any or all of them (or roll your own). In order of granularity:

Of course, each of these options requires that you give something up; if you serve cached content you are serving old (not real-time) content. But depending on what your app is, that may be entirely acceptable. And if so, all you have to lose are performance and scalability problems.

Using Delayed or Batch Processing
One of the most important (and least trivial) concepts in the real-time discussion is the use of delayed or batch processing. The best way to understand the idea is via examples. So:

In all of these examples, some processing is postponed and/or batched. The result? Not only are the applications faster and more scalable, but the developers also have greater control over exactly what operations occur and when.

Conclusion
Real time has become the norm by default, not by necessity. And real time causes real problems. Database caching, dynamic output caching, and delayed or batch processing are all concepts that can (and should) be leveraged so as to improve application performance and scalability. The truth is, there is no right or wrong here - everything is a tradeoff. Not all options will always be usable (you'd not want to use delayed batched credit card processing, for example, if you are selling access to a paid Web site). As a developer you get to make the real-time versus non-real-time choice. The important thing is that you actually make the choice. And I think you'll find that most parts of most applications actually need not function in real time at all.