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.

So for those of you who weren't there (don't make that mistake next year), and as a reminder for those who were, here are some of the highlights.

Access to the Java Universe
Simple, accessible, fast, fun. All adjectives used to describe ColdFusion and CFML. And all adjectives that I've yet to hear anyone use when describing Java. That's not to say that Java has no value. It does. Java is powerful, portable, extensible, widely supported, respected (occasionally a prerequisite), and capable.

ColdFusion's strength is simplicity; Java's strength is raw power. Each is valuable, but combine the two and you end up with more than just the sum of their parts. ColdFusion is ideally suited for scripting user interfaces, database integration, and Web interaction. Java is ideally suited for back-end processing, heavy lifting, and component creation. As I have discussed in this column before, Java and CF are a match made in e-heaven.

For CF developers, this is one of the most compelling aspects of the Neo story. In Neo the entire Java universe is accessible to CFers, all with the simplicity that you've come to expect from ColdFusion. The new <CFIMPORT> tag makes it possible to interact with Java code right from within your CFML code, and custom tag abstractions make it possible to encapsulate even that simple interface. Leveraging Java back ends in Neo is easy, even easier than in straight Java.

Of course, as Neo is ColdFusion, all this extra power comes at close to no cost - you'll still write CFML; you'll still create CFM files; you'll still use <CFQUERY>, <CFOUTPUT>, and <CFINCLUDE>; and you'll still write apps as you do now.

As for Java, all those three-letter acronyms (most beginning with J), all the tags and components (the volume of which dwarfs what is available for ColdFusion), products, utilities, and APIs - all that is optional. But when you are ready for it, Neo makes it all amazingly accessible.

Localization and Internationalization
One of the most common criticisms of ColdFusion is its lack of Unicode and support for true localization and internationalization. As I demonstrated in Orlando, Neo addresses this issue once and for all. Neo is built on top of Java, which supports Unicode and internationalization as a core capability. As such, Neo inherits this support, making it accessible to ColdFusion developers.

Tags, functions, your own code - they can all be localized and globalized as needed, and all with minimal effort.

Application Isolation
Another compelling benefit, also the result of Neo's being Java-based, is application isolation. Simply put, in the Neo world, applications can run in their own virtual spaces - almost their own application servers.

Why is this important? Most ColdFusion applications run on shared boxes. Prior to Neo there was no way to restart individual applications, no way to terminate rogue applications without impacting others, and no way to implement application-specific settings.

The specifics of how this feature will work, and exactly what it will enable, have not yet been publicized. But one thing is definite: application isolation will make servers and applications more reliable, more manageable, and more stable than ever before.

Compiled Code
ColdFusion 5 (and earlier) is essentially an interpreter - CFM files are read and then compiled into p-code in memory. The CFM files must always be present; there is no way to save or distribute compiled code.

Neo changes this. In Neo, CFM files are compiled into Java .class files that can be executed, deployed, and even distributed. Compiled applications will need a Neo license to run. Exactly how this feature will be made accessible has yet to be announced, but regardless, the fact that ColdFusion executes compiled code (instead of interpreting code) means that your apps will run faster, your source code will be more secure, and additional deployment options will be possible.

A Whole New Level
It's official: Neo is the next major version of ColdFusion, it's built on Java, and it promises to take CF development to a whole new level. All of the features and capabilities mentioned here were announced at the Developers' Conference at the first General Session. And all of these features and capabilities are the direct result of a significant architectural investment that we've been working on for a long time now - porting the core ColdFusion engine to Java. It's been a long journey, but the results are proving that it was a worthwhile one to make. Visit www.macromedia.com for more information.