Rob Brooks-Bilson

I haven't seen this one mentioned anywhere in the huge number of ColdFusion 8/Scorpio posts that have been popping up lately. It's a relatively minor addition to the cfmail tag for setting message priority. In ColdFusion 6.x/7.x, if you wanted to set message priority, you needed to use a separate cfmailparam tag like so:

In ColdFusion 8, the same email can be written like this:

The priority attribute is optional and can contain an integer (1-5 with 1 being the highest priority) or string value (highest|urgent, high, normal, low, and lowest|non-urgent).

This isn't huge, I know, but it's just one more way ColdFusion 8 makes even little things easier than ever before.

By now, you've probably read the Computerworld column titled "The top 10 dead (or dying) computer skills" by Mary Brandel. In it, she lists 10 technologies she considers dead or dying. Coming in at number 5 is ColdFusion.

With all the recent buzz over Scorpio, as well as a recently released report by Evans Data citing the number of ColdFusion developers at over 400,000 (see this post from Matt Woodward's writeup of Tim Buntel's D.C. Scorpio presentation), it's hard to see how she can justify saying that ColdFusion is dying.

In fact, all of the evidence I've seen points to exactly the opposite:

• Adobe has gone on record stating that the number of ColdFusion devlopers is up from previously published numbers.
• Sales of ColdFusion have continued to grow steadily
• Adobe has made a significant investment in ColdFusion 8
• The number of companies looking for ColdFusion developers has increased dramatically.

ColdFusion is in use at most of the Fortune 100 companies as well as most branches of the U.S. government. It's much more heavily utilized for Intranets and corporate applications behind the firewall, so that maybe where a lack of "public" visibility comes from.

I think what this latest round of FUD surrounding ColdFusion boils down to is this. The state of technical writing in trade publications such as Computerworld is abysmal. Top ten type lists are easy to write and garner a lot of attention. The source of information for the ColdFusion piece of the story is a small technical recruiter in a small state (Connecticut). It's hardly representative of where ColdFusion is in the marketplace. How do you think the results would have read had the writer contacted a recruiter in D.C. where there's a quite heavy concentration of ColdFusion shops?

My point is, the article just isn't accurate when it comes to ColdFusion, or C for that matter. The only way to combat this type of bad reporting, though, is to make your voice heard. Ray Camden has a good suggestion on his blog, where he suggests leaving feedback (politely) for the reporter letting her know your thoughts on the article.

The moment you've all been anxiously awaiting... Adobe has finally announced the dates and locations for MAX 2007:

• MAX North America: September 30 - October 3, 2007, Chicago, IL
• MAX EMEA: October 2007, Barcelona, Spain
• MAX Japan: November 2007, Japan

It looks like this year's MAX will cover the entire Adobe product range, which should make for an absolutely huge event. Couple that with the release of Scorpio (ColdFusion 8) sometime this year, and I think you have the makings of a great conference.

There currently isn't any information available on the Adobe website, but you should expect some soon.

I hope to see many of you in Chicago this year!

I'm in Ashwin J Mathew's Unlocking the ColdFusion Server Black Box session right now. I had the opportunity to talk with Ashwin a bit last night, so I was pretty excited to see what he had to formally say on Scorpio's new server monitoring capabilities.

Right off that bat, he's showing screen shots of the application, which has a nice Flex front end. The server monitor is a ColdFusion app with Flex up front that runs within the ColdFusion administrator. It's useful for analyzing problems during development as well as pinpointing bottlenecks on production servers. It allows administrators to monitor overall server health. It's safe to run on production systems.

The Summary Screen shows JVM memory status, average request time, slowest active requests, reports, alerts, and errors. From there, you can pull up all sorts of other reports, charts, and graphs. Some of them are being demonstrated...

The template cache graph shows you exactly how the template cache is performing. Reports for slowest queries, slowest queries by average, queries by memory usage, and query cache.

Lots and lots of questions about how exactly certain features have been implemented, and lots of people asking for additional functionality. Ashwin's stated that the monitor isn't done yet, so there's most likely more to come. The monitor can also be used to track and analyze errors and timeouts.

The monitor can also be used for detailed request profiling. You can take a given request and show exactly which tags and functions are taking the most time to run. There's no code to add, just run the profiler and get the information you are looking for. The profiler also is useful for analyzing memory usage. It shows how much memory each variable is consuming. It shows the variable name, type, memory size, and what template is responsible. The report currently covers the top 10 largest variables, memory foot print wise. AWESOME!!!

There's a snapshot feature that allows you to take a snapshot of your server at any point in time and dump out the results for analysis.

You can also create alerts for various conditions you want to monitor. There are alerts for Hung Server and Slow Server. You can also create your own Alert types by creating custom CFCs.

Requests can also be filtered for monitoring, allowing you to include/exclude certain aspects of your site/server for monitoring.

Lots more reports including active sessions, active queries, request throttle data, database connection pool, highest hit counts, and more!

Lots of switches for turning on/off various aspects of the monitor: monitoring (everything), profiling, and memory tracking. Each aspect has a performance impact. Monitoring and profiling are minimum. Memory tracking can have a significant impact.

Finally, the infrastructure that supports the server monitoring app is CFC driven. What's particularly cool is that the whole thing is exposed as an API (servermonitoring.cfc) , allowing you to build your own applications and interfaces using the underlying monitor. Currently, there are between 40 & 50 methods.

The server monitor certainly shows a lot of promise. It's something we've been asking for for a long time. One interesting question is will it replace, or complement tools like SeeFusion and FusionReactor?

I'm sitting in Rupesh's ColdFusion .Net Integration session right now. The main benefits of .Net integration has to do with leveraging some .Net functionality within ColdFusion. Adobe has no plans to port ColdFusion to the .Net platform, but their integration strategy should make it easier to leverage MS products like Excel, Word, Outlook, Exchange, etc. The .Net integration will also let you integrate with components and services created in .Net.

Right now, the only way to integrate with .Net is via web services, messaging, or by using COM. With the Scorpio release, you'll be able to integrate with .Net using what's called Runtime Unification - just like we do now with COM, CORBA, and Java - via createObject() and the cfobject tag (type=".net").

The Runtime Unification makes .Net assemblies locally available. It gives you more fine grained control than the previously mentioned integration strategies. Benefits include:

• Tight coupling
• Fine grained control as it's a local object
• High performance, reliability and security
• Stateful
• Communication can be binary (default) or http for use across firewalls
• Supports SSL

Syntax for calling looks like this:

Rupesh then went on to show an example of using a few lines of code to generate a MS Word document. It was FAST and relatively simple to do. Finally, native integration without having to use COM or Apache POI!

There's also automatic datatype conversion fr primitive .Net datatypes to CF and CF to .Net. Decimal type is not supported. You can also use javaCast() where required (ambiguous method arguments).

There's a chart for datatype mapping from .Net to Java. All primitive types are supported except for decimal.

Deployment scenarios include ColdFusion and .Net on the same server, ColdFusion and .Net on separate Windows machines, and ColdFusion on other platforms with .Net installed on a Separate Windows machine. Each of these configurations has various configurations and steps required to make it all work. The simplest is CF and .Net on the same machine, but it will work across all three of the options.

Some limitations: Enum and decimal datatype not currently supported. Methods with out parameters as arguments and methods with pointers as arguments or return types are also not supported. Unfortunately, you also can't use .Net UI components. Callbacks are also not supported.

Tariq Ahmed's put together an interesting survey trying to understand what features people want to see in the next version of ColdFusion (ColdFusion 8). Tariq just released the results of the survey, along with the raw data from SurveyMonkey.

I was initially surprised at the results Tariq published on his blog, as what I saw there didn't match up with what I'd been reading in various blogs, mailing lists, or forums (for example, Image Manipulation came in at number 16, something I know to be one of the top requested CF featues for several versions now). Wondering what the raw data looked like, I downloaded Tariq's spreadsheet.

I tried posting my questions/findings directly on Tariq's blog, but after my first comment, the comment system there ate my next attempt (I'm guessing it was too long). In any case, apologies Tariq for making a separate post...

I don't claim to be a statistician by any stretch of the imagination, but I did have an undergrad class or two in statistics and survey design, and two things didn't seem quite right to me.

First, the question style used is somehting known as a Likert-type question. It's a question used to measure attitudes toward a particular construct:

1 - Strongly Disagree
2 - Disagree
3 - Neither Disagree or Agree
4 - Agree
5 - Strongly Agree

Technically, this is known as the Likert-scale, however I'm referring to it here as Likert-type because Likert-scale questions are always used with multiple related items, and the survey here deals with single, unrelated items (individual features).

In a survey using Likert-type questions like this, a response of neutral shouldn't be "scored" as meaning that someone wants a feature more than they don't. If you are assigning a value of 3 to a neutral response, and using that to calculate a mean score, you are making that response seem as if a respondent wants the feature more than they don't (which isn't the case). One of the big issues in using a Likert-type question in this type of survey is that the responses are ordinal because it can't be assumed that people filling out the survey will perceive the difference between adjacent options as being the same. In other words, the value assigned to them (1-5) is positional, not representative of an actual mathematical value.

One common way Likert-type questions are scored/analyzed is to combine all of the like/agree responses into one group and all dislike/don't agree answers into another, discarding all of the neutral answers. Since the question we're trying to answer here is what features are most important to people for CF 8, it seems to make sense to just combine the want/really want, and rank the items from there. This answers the question "what do people want to see" vs. what are people ambivalent about, or what aren't people interested in seeing (which you could extrapolate from the survey as well. If I order just based on what people voted that they want to see, here's the order or preference I ended up with. Out of 317 respondants, here's what people wanted (ordered by the number of people indicating "want it" or "really want it":

243 Image Manipulation
233 Improved Crash Prevention
232 IDE/Hooks into better interactive debugging
229 Access to Server Internals/Metrics
222 Add PDF Forms Support
216 Give us an IDE with CFC introspection
215 Improve CFDocument
211 AJAX Abilities
210 Control logging at the application level
209 Improvements to large file parsing
209 Create/Extract/Manage ZIP Files
202 Tools to debug remoting and gateways
196 Add native support for MS Office formats
190 Strong Integration w/Exchange (Mail/Calendar/Etc...)
189 Threading/Thread Management & Protection
186 Add native support for RSS
184 Add cache control at the app level
184 Manage many CF Servers from a single console
181 Enhanced flash forms using Flex 2
175 Improved Reg-Ex Support
173 Upload to a Variable instead of Disk
168 Add granular control of DB and content caches
156 Faster validation abilities (E.g < validator Flex's borrow or , validValues="x,y,z"> 154 Integrated CF8+Flex FDS Install
153 CFAdmin Tools for creating Event Gateways
149 Add non-DOM based XML Parsing
149 Strong IMAP Integration
144 Make CFC Instances Serializable
143 Plug-In Architecture
141 CF Desktop Plugin to support drag and drop upload
137 CF to CF Communications via AMF (vs XML)
132 Add CSS/HTML pod layout support
128 OO Abilities: Constructors
119 Add refactoring to an IDE
116 Ability to deploy customized+scripted CF Installations
115 3rd Party Updates
114 Web Interface Hooks into JRUN Configuration
113 Static Methods in CFCs
113 Sandbox Security Enhancements
109 OO Abilities: Interfaces
107 Integration of Breeze Functionality
98 Tomcat & JBOSS Support
94 OO Abilities: Function Overloading
90 SNMP Gateway Service
77 Add accessibility 508 checking to an IDE
72 OO Abilities: Destructors
58 Mustang Support
56 Trend to be more Java like
55 E4X Support

If you really want to use the mean for each question, you should get away from a Likert-type question with a neutral value, and just use a scale of 1-5 with one being no interest and 5 being strong interest.

What all of this really illustrates is just how difficult it can be to design surveys and interpret their results. I really wish tools like SurveyMonkey would do more to help reduce ambiguity in surveys, as well as provide better analysis tools for the data generated.

At the urging of several people, I've taken my Blackstone Wishlist, stripped out requests that made it into CFMX 7, 7.0.1, and 7.0.2 as well as requests that have already been mentioned on a plethora of other blogs (many of which I would like to see), and came up with the following things I'd like to see considered for the ColdFusion MX 8 (Scorpio) release. Apologies for any requests that may have already been mentioned on other blogs.

Drum roll please (in no particular order)...

1. I'd like to see a config file (CF, XML or otherwise) that runs when the server is restarted. This file could contain info on queries to automatically run and default variables to be assigned for the server or defined applications.
2. Add functions to programmatically list all current sessions/applications on a server (without the Java workarounds we're currently using). Include info such as when the session/application was started, how long until expiration and whether or not it has already expired. Examples are getSessions(), getClients(), getApplications(), getSession(), getApplication(), etc
3. Enhance the CF Scheduler so that it can operate in a cluster. I want to synchronize events between servers in a cluster so that you can setup a scheduled task on any server, and it would replicate out to all the other servers (similar to the buddy server concept), but the event would only fire on a single server, not on all of them at once
4. Further enhance the cf scheduler to use its own thread count (as opposed to the one that's defined in the CF Admin now). This would allow the scheduler to use a different threading model than "active" applications on the server
5. Ability to put a scheduled task on hold. Currently there's no way to temporarily disable the execution of a schedule task without deleting it (or changing the execution URL to a non existent page).
6. Addition of weekday and weekend only durations. Currently, you can schedule a task to execute daily every n hours/minutes/seconds, but there's no way to specify you want this to occur only Monday through Friday (business days) or only on Saturday and Sunday. Sure you can code this into the pages you are executing, but that code has to be used with each task. It's much better if this can be made part of the scheduler.
7. Task execution redundancy. Currently, if a scheduled task fails to execute (for instance if the server is being rebooted during execution time), there's no mechanism in place to automatically attempt to re-run a task. I've built this type of redundancy into several applications I've written that have scheduled tasks, but again, it has to be done on a per application/per server basis.
8. Better reporting on task execution. I'd love to see a new column on the ColdFusion Administrator page for scheduled tasks that shows the last date/time the task was successfully executed as well as the next date/time the task was scheduled to execute. This would be invaluable for monitoring and troubleshooting.
9. Deprecate cfscript. This would keep people from asking for more enhancements, when it's probably not going to happen. I used to be for enhancing cfscript, or throwing it out and allowing ActionScript in CF instead, but these days, I'm perfectly happy with all tags (I guess I'm mellowing out in my old age).
10. Mechanism for dealing with name conflicts (overriding) with native CF functions/tags in order to future proof. So, if I already have a UDF called wrap(), upgrading my version of CF won't break my app when CF get's its own wrap() function
11. Build stronger partnerships with companies like IBM, Actuate, etc to get support for CF into their products
12. Make CF's security framework more granular. I always need an additional level of security beyond roles. How about groups, roles, and permissions. While you are at it, give us a way to programatically get a list of users currently logged in, their roles/permissions, etc
13. Add IMAP, NNTP, and SNMP tags
14. Since there is already support for Crystal Reports via cfreport, I'd like to see integration with Actuate too. It's J2EE based, so I would think that there are several integration points possible here.
15. Add the Lotus Notes JDBC driver, free from IBM to the list of native drivers
16. Fix reFind() and reFindNoCase() to return the positions for all matched subexpressions
17. Spell check tag
18. When a hotfix is applied, log it in a server var available in the CF Admin so that an admin can tell what hot fixes have been applied
19. Add a TRACE attribute to CFQUERY for debugging so that we can see what CF is doing with the underlying JDBC driver. Most drivers have a trace capability that can be logged to a text file, but I'd like to see what's happening from a CF's perspective so I can see exactly what calls to my drivers it is making
20. Scrap the JS validation in CFFORM and implement the qForms JS API from PengoWorks. It's much more powerful, flexible, and extensible and works very well with CF.
21. Add an interface to the CF Admin to allow me to "reset" a datasource without having to restart the CF server. Right now, several of my iSeries DB2 data sources (JTOpen driver) occasionally hang. The rest of the CF server is fine as are the rest of my data sources. In order to free the hung data source, I have to restart my CF Application Server service. I would rather kill the connection to the hung data source and restart it (if that's how it works) without having to restart the server. It would be even better if I could to this programmatically, so I could call it from a cfcatch block if I detected the specific error a hang causes
22. cfsocket tag (like in DRK5)
23. Better caching than cfcache provides. See Brandon Purcel's CF_Accelerate. Not sure if you could replace cfcache with this or if it would be a new tag. I'd also like to see improved query caching options.
24. In the CF Admin (and programmatically), give us a way to see and admin (expire) cached queries.
25. Allow for mappings on an application level so that mappings defined in the CF Admin can apply to either the entire server, or a specific application.
26. Official framework for unit testing CFCs
27. Support for portlets as outlined in JSR 168 and JSR 170. I'd really like to see the ability to create a portlet in CFML, then have CF generate a WAR file for the portlet that can be deployed to any compliant portal server.
28. Allow parameters for the JDBC URL to be passed dynamically at run time if possible. For example, right now, if I want to add an extra parameter to my data source just for testing, I can't do it from the cfquery tag. I have to go in and make the change in the CF Admin, and then change it back later if I want to "undo" it.
29. Integrate with JMS (I know that Sean worked on an example JMS gateway, but I'd like to see it become "official")
30. Allow sorting scheduled tasks within the CF Admin alphabetically by name, or time (interval). I have a server with 600+ scheduled tasks, and I'd like to group by time so I can tell whether I need to move any to a different time to avoid using too many of my server's available threads.
31. Within a CFC method (and a UDF), allow us to VAR variables anywhere, not just at the beginning of the method. I often need to var a variable with a value that is dependant upon another condition (such as a conditional based on an argument being passed in). Because I have to var before any other cfml statements, I first have to var the variable and set it to empty (var=""), then do the conditional later. I'd like to see VAR implemented like in JavaScript. It would be great to var a loop variable inline, as opposed to at the top of the page for example
32. Make it possible to deploy a "clone" of an existing instance of a CFMX deployment right from within the CF Admin of that instance. Similar to your archive and deploy, but have the deploy actually create the new instance and then clone the original
33. Make it easier to tie a different jvm classpath to each instance of CFMX when using multiple instances.