Products

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.