SitePoint » ColdFusion

CloudSpring: 11 Things Every Developer Should Know About the Cloud

Toby Tremayne — Mon, 19 Dec 2011 06:03:04 +0000

Cloud computing opens a world of possibilities for software and developers, but coding for the cloud isn’t necessarily as straightforward as you might think. The learning curve for developers can be tricky—especially for web developers unused to working with concepts such as threading and concurrency, latency, asynchronicity and failure tolerance. Here are 11 things you need to watch out for when you start developing for the cloud. Compliance & Governance Legal and operational requirements often dictate the location of your data storage and hosting, and in the cloud it’s no different

ColdFusion 9 at Your Service: Image Manipulation with AIR

Kai Koenig — Wed, 28 Oct 2009 23:57:56 +0000

Earlier this month, Adobe released the latest version of ColdFusion at
the MAX conference in Los Angeles. Back in July I gave an overview
of ColdFusion 9, covering some of the new features with the benefit
of Kay Smoljak’s examples. This article is about one juicy new feature that
we omitted in that article: ColdFusion as a service (CFaaS).

CFaaS is a new way of accessing some of ColdFusion’s functionalities
as remote or local services. For example, and , which were previously only
available as CFML tags and could therefore only be used in
.cfm documents running on your server. With CFaaS, your
client-side code can access these ColdFusion functionalities with web
service calls.

With the current trend towards richer applications based on Flash,
Flex, AIR, or AJAX on the client side, it made sense for Adobe to give
ColdFusion 9 a service layer. This allows RIA developers to leverage some of
ColdFusion’s rapid application development functionality in their
work.

To illustrate how you can take advantage of this new service layer,
I’ll show you how to build a simple AIR application that will act as a front
end for image processing tasks taking place on the server side. We want to
be able to drag and drop an image into the application, upload it to a
ColdFusion server, perform some CFaaS functionality to modify the image,
then retrieve the image to be displayed in our application. Finally, users
will be able to drag and drop the modified image back into their file system
as a JPEG file.

Before we start, here’s what you’ll need:

ColdFusion
9 from Adobe. Download and install the free developer
edition.
Flash Builder 4
beta 2 from Adobe Labs, which we’ll use to build our AIR app.
We’ll be using the Flex 3.4 SDK, so you could in theory use Flex Builder
3 for most of what we’ll be doing, but Flash Builder 4 will simplify a
few key tasks.
The sample code, which is available
here. The archive includes both an .fxp
project that you can import into Flash Builder, and the raw source files
in case you want to look at them on their own.

Once you’re done reading the article, head over and test your new
skills in our Article
Quiz!

The Basics

Before we start working through the example, let’s have a look at
some basic CFaaS features and how we can make use of them. In ColdFusion
9, the following tags and their functionality are available as
SOAP/WSDL-based web services:

The WDSL URLs for these services follow the format:
http://:/CFIDE/services/.cfc?wsdl.
So, if you installed ColdFusion 9 on your local machine using its built-in
HTTP server, the WSDL URL to access the image service will be:
http://localhost:8500/CFIDE/services/image.cfc?wsdl. All the
examples and sample code will be using this format, so if you’re using a
different server name or port, you’ll need to adjust the URLs
accordingly.

The WSDL URL of a service essentially exposes the entire service
API, and this can pose a significant security risk. Because of this, the
CFaaS engine is disabled by default, so you (or your ColdFusion server
administrator) will need to set up a user account for the CFaaS layer and
provide that user with appropriate access to the individual services.
You’ll also need to provide a list or range of IP addresses that are
permitted to access exposed services. For the purpose of this exercise
we’ll just be accessing the service from our local machine, so you’ll only
need to add 127.0.0.1 to that list.

To add the user for our service, we’ll first log in to the
ColdFusion server administration area, located at
http://localhost:8500/CFIDE/administrator/index.cfm. The two
screens we’ll need are both found in the Security
section: User Manager and Allowed IP
Addresses.

Figure 1. ColdFusion Administrator menu

First, in the User Manager screen, create a
user, specifying a username and password. At the bottom of the screen,
move Image Service from the list of prohibited
services to the list of exposed services.

Figure 2. User Manager

Nevermind the other sections of this form, you can leave them alone
for the purposes of this application. Make sure to remember the username
and password you set for your new user, as you’ll need them to permit your
AIR app to access the image service.

Five Stars! Add a Rating Widget to your ColdFusion App

Kai Koenig — Tue, 25 Aug 2009 14:00:00 +0000

ColdFusion 9 – The latest version – has just recently been released as a beta preview on Adobe Labs. ColdFusion is Adobe’s server-side platform for web application development and we’re jumping on this opportunity to use it in combination with the brand-new ColdFusion Builder. We’ll develop a rating widget, so that you can provide your users with the option to rate content on your web site. The source code for this article is also available for download.

Once you’ve read the article, why don’t you test your knowledge with our quiz? If you’re one of the first 200 to complete the quiz, Adobe will send you a printed copy of the Adobe ColdFusion Evangelism Kit.

Before we start let me say that this tutorial assumes that you’ve installed a stand-alone ColdFusion 9 server on your local development machine in a non-J2EE deployment and that this server is running on port 8500. If you have set up your server in a way to use a locally installed HTTP server like Apache or IIS, you might need to place the files I’m mentioning in a different location on your hard drive, as well as change all port references to port 80.

Setting Up The Database

All right, let’s start! Our task is to add a rating widget to a ColdFusion application or page. Therefore, we need to have a ColdFusion application first, and the easiest way to achieve that is by creating a few database tables to store content and ratings. If you’ve followed Kay Smoljak’s tutorial on building a URL shortener application, the easiest way is to just add a rating table to the existing Derby database. You can do so by executing the sql/db.cfm file of the download package for this tutorial.

For those users of SQL Server, we aim to keep this tutorial as straightforward as possible. So rather than dive into the depths of database schemas, here’s a screenshot of the schema diagram and how the two tables are related.

Database schema for content and rating table (View larger image in a new window.)

SQL scripts that create the two tables on SQL Server 2005 or 2008 are part of the download package (you’d have to create the Content table first, as both scripts assume there’s a database named "sitepoint" already existing on your SQL Server). Keep in mind that this is just an example; the column definitions of the Content table are arbitrarily chosen and the only requirement is really to have a unique content identifier that can be tied into the rating table to associate both entities.

Importing the Project into ColdFusion Builder

In Kay Smoljak’s and my article “What’s new in ColdFusion 9“, we’ve discussed a variety of the new features in CF9. Among those is the aforementioned ColdFusion Builder. The code samples for this tutorial come as an exported CF Builder project and can be imported into your own project using the import wizard in the File menu of CF Builder. The image below shows the project’s file and folder structure.

CF Builder project structure

Displaying the Content

The first file we’re going to look at is index.cfm. Let’s pretend this is the main application file that’s supposed to query and show the content:

... 

 

  oContent = CreateObject("component","nz.co.ventego.sitepoint.Content"); 

  data = oContent.getAllContent(); 

 

 

   

   

    http://#cgi.server_name#:#cgi.server_port#/URLS/?#data.shortlink# (id: #data.id#)
 

    (#data.link#)
 

     

      Do you like this content? Why not rate it...
 

    
 

    

 

    
 

   

 

...

The top block instantiates a CFC (ColdFusion Component) and calls the method getAllContent. The method executes an SQL query against our database and retrieves a list of all Content entries, together with the amount and the average value of ratings (we’re allowing users to pick a score between one and five stars):

SELECT   C.id, C.label, C.text, C.link, C.shortlink, AVG(R.rating) as average_rating, COUNT(R.id) as number_of_ratings 

FROM  Content C 

LEFT JOIN Rating R ON C.id = R.contentId 

GROUP BY C.id, C.label, C.text, C.link, C.shortlink

The resultset of this query is stored in the variable data on the page and can now be used there. The tag’s query attribute loops over the query resultset and for each row of the query, the HTML content from

to is created, as shown below.
Database output (View larger image in a new window.)
While looping over the `resultset` ColdFusion will evaluate the expressions that are embedded between the #-symbols and replace those with data from the `resultset`. As you can see in the code, we’re using the `shortlink` and `link` columns from Kay’s tutorial to rate the shortened URLs her application created. Let me just point out that the Content table has columns to store a label and text as well – so feel free to store whatever data you like in there, and change the display logic shown above in `index.cfm` to tweak the output for your needs.

The Custom Tag

The rating widget will be implemented as a ColdFusion custom tag. Custom tags were introduced into ColdFusion back in the days of ColdFusion 3 or 4 but are still the most efficient and preferable way to create modularized functionality for the direct purpose of creating page output. From a high-level point of view a custom tag is nothing more than including a .cfm file into another .cfm file, but we’re in fact following a few guidelines and requirements in writing and accessing this custom tag.

A CFML custom tag can be called via and gets passed so-called custom tag attributes by specifying key-value pairs. Our rating widget will need to be passed three pieces of information: the content identifier it’s supposed to be tied against, the average current rating, and the amount of ratings that we’ve already received for this content. We’ll place the following line right after the ... block in index.cfm later to embed our widget:

The widget code itself is placed in the subfolder customtags and named widget.cfm. The latter indicates again that our custom tag is simply a normal .cfm template written in a specific way. The custom tag itself is surprisingly concise, partly due to the fact that we’re leveraging the Ajax framework, Spry to help us with managing the rating mechanism itself. Let’s have a look at the custom tag first:

  

    

    

      

        

          

          
The current score is #DecimalFormat(attributes.rating)# based on #attributes.ratingcount# votes.
  

          

          

              

              

              

              

              

            Thanks for voting!  

              

          

      

          

      
  

      

    

    Please supply a contentId value to use this widget for rating content

A custom tag has different execution modes. The idea behind this concept is that one should be able to “wrap” a custom tag with opening and closing tags around other existing content on a page and apply whatever functionality the tag provides to the enclosed content. In our case, we just want to call the custom tag once to actually include the rating widget and attach it to an item on the page. At the beginning of the custom tag, we’re therefore just checking if the execution mode of this tag is “start”. If the tag is used in any other mode, no output is created and the custom tag has no effect.

Everything that’s been passed into the custom tag from the index.cfm via the tag ends up in the so-called "attributes scope" within the custom tag. We’re checking if the contentId has been passed in and therefore if the variable attributes.contentId is defined. If that’s the case we can at least safely run the rating widget. If the developer using our widget.cfm passes in both a value for attributes.rating and attributes.ratingcount, we’ll display information of the current average score and the amount of votes for that content item.

Adding Ajax with Spry

After this conditional CFML code, the real rating widget is being set up. As mentioned earlier, we’re going to use some widgets from an Ajax library called Spry. Spry is a lightwight collection of widgets, effects, and other useful Ajax-related classes developed by Adobe that’s been released under a BSD license. The nested set of tags creates the rating widget itself and five elements of class ratingButton inside. We also throw in a message to be displayed after the user has voted and an element to store the current rating. The latter will allow our rating widget to reveal the average score (in stars) at that point when it’s loaded (see the figure below). It’s worth mentioning that Spry is obviously not the only way of creating a dynamic and Ajax-based widget; other JavaScript frameworks such as jQuery or extJS are also able to provide a solution.

Preloaded "stars" to reflect the average score

Below the section of nested tags we’re actually instantiating an object of the Spry.Widget.Rating class in JavaScript. In our scenario we’re going to have multiple content items with a rating widget each on a single page, so we’ll have to make sure that we’re creating individual instances of the Rating class. This is done by naming the instances rate_content_#attributes.contentId# – the ColdFusion expression in #’s is evaluated on the server before the HTML is delivered to the client and the JavaScript is executed there. The constructor of the JavaScript object is passed a reference to the id of the section we created just before, as well as an object of properties and settings.

The latter is of particular interest as it allows us to customize the Spry widget in a variety of ways. In this case here, we allow a user to vote just once while being on the page (without additional checks on the server they can vote again when they reload the page) and we define a saveUrl in combination with a postData query string. As soon as a user of the widget clicks on a star, we’re sending the current contentId and the selected rating to the rate.cfm template via a POST request.

Data that has been sent to a CFML page via a POST request becomes variables in the form scope; then the core task of rate.cfm is to check if contentId and the rating are actually defined in the latter, before executing a SQL statement to insert the new rating into the Rating table. For this data access, we’re following a similar pattern to what we used in the data retrieval before:

Create an instance of a data access CFC: oRating = CreateObject("component","nz.co.ventego.sitepoint.Rating");

Call a method of the previously instantiated component: oRating.insertRating(form.contentId,form.rating);

The Rating.cfc‘s insertRating method executes the following SQL query:

  

  INSERT   

  INTO Rating(contentId,rating)  

  VALUES (,)

An Important Tip

Although indirectly related to the rating widget tutorial, it’s worth mentioning this query is an example of two very important best practices that regularly are forgotten by CF developers:

Always use the tag when you’re creating dynamic SQL queries – otherwise you’re creating a barndoor-sized security gap and opening yourself up to SQL injection hacks. ensures at least the correct type of data and additionally creates a parameter binding, which usually executes faster than just using ColdFusion variables, as in ...VALUES ('#arguments.contentId#')....
Remember to scope variables that are local to a function. Until ColdFusion 8 that had to be done by declaring function-local variables by using the var keyword, as in: . ColdFusion 9 has introduced a new, alternative (and in my opinion, better) syntax by offering the local scope as shown above by naming the query object local.qRating.

Finishing Up

With that last step we have everything covered – nearly. When we were looking at the index.cfm file earlier in the tutorial, we just saw a snippet of CFML code, rather than all of it. Because our page and the widget.cfm use the Spry Rating class, we need to make sure we import those particular JavaScript and CSS files from the Spry library:


    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  

  

  

  ...

There’s also an additional style rule for the thankyou HTML class to position the "Thanks for voting" output. The final output is shown below.

Thank-you message

The user has given the content 4 stars; a revote, as such, is impossible. Reloading the page provides updates to the score and amount of votes, and does enable this user to vote again. There are a variety of possible extensions of this widget to work around this issue and the feasibility of each depends on the use case of the widget. One could think of implementing a very simple, cookie-based solution, but also tie the widget into a proper authentication model that keeps track of user sessions and identifiers; that way, you could prohibit multiple voting on the same content by a given user.

So how would you rate your knowledge? Test yourself with our quiz and, If you’re one of the first 200, receive a printed copy of the Adobe ColdFusion Evangelism Kit. Don’t forget to download the ColdFusion 9 preview, the source code from this article, and have a go at building your first ColdFusion app.

Build Your Own URL Shortener

Matthew Magain — Wed, 05 Aug 2009 13:54:40 +0000

URL shorteners are all the rage—tinyurl.com, tr.im, ow.ly, bit.ly … even Digg are getting in on the action. But wouldn’t it be cool to write your own?

It turns out that doing so is not so hard. We’ve just published Kay Smoljak’s latest article Get Shorty: Trim the Fat with ColdFusion, which takes you step-by-step through the creation of a simple URL-shortening web app in ColdFusion 9. It also comes with a handy little quiz, sponsored by Adobe, to test your understanding of the tutorial.

Now hold your horses folks—we know ColdFusion isn’t for everyone. If ColdFusion isn’t your bag, or you reckon you can write this app in half the time in your favourite development platform, then that’s fantastic. But if you’re interested in reading about how to do it in a super elegant way using the ColdFusion Builder tool, then this is definitely the article for you. You might be surprised.

Check it out.

Get Shorty: Trim the Fat with ColdFusion

Kay Smoljak — Tue, 04 Aug 2009 14:00:00 +0000

Tired of the same old URL shorteners like TinyURL, tr.im or bit.ly? Ever wished you could run your very own URL shortener? In ColdFusion, it’s probably easier than you think. To demonstrate just how powerful and easy to use ColdFusion is, we’re going to build our own simple URL shortener from scratch. In this article, we’ll start out with a basic set of functions – creating shortened links, and expanding them. Don’t forget to try the quiz when you’ve finished reading!

To follow along, you’ll need to download and install the ColdFusion 9 and ColdFusion Builder betas and install them on your development machine. ColdFusion 9 is also available for Linux, and it is possible (with some tweaking) to install ColdFusion Builder – see this tutorial at Compound Theory for details. You’ll also need to grab the code archive for this tutorial.

Before we start

This tutorial assumes that you have ColdFusion 9 beta running on localhost, on port 8500, using the stand-alone, built-in development server. If you’ve installed ColdFusion on a machine other than localhost, or are using IIS or Apache instead of the stand-alone development server, or are using a J2EE server configuration, you’re going to need to change the server paths mentioned in the code listings.

We’re also going to assume that you have ColdFusion Builder installed on the same localhost machine. If you already have the Eclipse IDE on your machine (including Flash Builder or Flex Builder) and have installed ColdFusion Builder as a plugin, you’ll need to make sure you’re in the ColdFusion perspective: from the Window menu, select Open Perspective > Other > ColdFusion.

Before we start coding, we’re going to tell ColdFusion Builder which ColdFusion server we will be working with. We’ll configure this using the Servers tab at the bottom of the ColdFusion Builder window. There are quite a few steps to follow here, which I’ve broken down for you below:

Click on the Add Server icon – there’s a little yellow plus sign on it.

Select ColdFusion as the server type, and click Next.

Enter a name for the server – this is so it’s recognizable to you. I’ve entered localhost.

Enter the hostname – if you’re running the default setup, it’s localhost too.

Enter the port – the default for the built in development setup is port 8500.

Enter the RDS User Name, which is always admin, unless you specified a different username when you installed the server (this is usually only the case if you’re running on a J2EE server configuration).

Enter the RDS password you specified when installing ColdFusion. Click Next.

Browse for your Server Home. This is the directory where ColdFusion was installed – on Windows, it will probably be C:\ColdFusion9; on the Mac, /Applications/ColdFusion 9.

You might also need to browse for your Document Root. This is your web root – on a default Windows installation, it will probably be C:\ColdFusion9\wwwroot; on the Mac, it’s at /Applications/ColdFusion9/wwwroot.

Select the version of ColdFusion installed from the drop down box – 9.0.x.

Click Finish.

ColdFusion Builder will verify these details and connect to the server. If all went well, you should see the server in the Servers tab. You can start and stop the server and access its ColdFusion Administrator panel from this tab.

ColdFusion Builder works with projects. We could create a new project now, and associate it with our development server, but to make things easier for you we’ve included all the code in a downloadable project which we’re now going to import.

Download the sample zip file and extract the folder into your ColdFusion web root. Change the name of the folder to URLS now, if needed.

The navigator panel on the left hand side of the screen shows the files in your current project. Right-click in the Navigator and select Import.

From the Import wizard, drill down to ColdFusion -> Import Existing Projects, and click Next.

Browse for the folder you just extracted.

ColdFusion Builder will scan the folder and look for any project files, which will then be listed in the Project List below. Check the box next to our URLs project, and then click Finish.

The project will now be listed in your Navigator panel. The last step is to associate the project with our server.

Right click on the project name and select Properties.

Select ColdFusion Server Settings from the left hand side of the dialog.

Select your local development server from the drop-down box of servers, and click OK.

Setting up the database

Our URL shortener application will need a database. Apache Derby is an open source database with some fairly heavy-duty features, and it’s built right in to ColdFusion 8 and later. For our purposes, it’s perfect, because although Derby has no client and no user interface, setting up databases is very simple and there’s no need to install MSSQL, MySQL, or other database server.

ColdFusion uses data source names to store database connections. Data source names are set up in the ColdFusion Administrator, which is the command central for your ColdFusion Server. To access the ColdFusion Administrator for your local development server, right-click on the server name in the Servers tab (remember, it’s down the bottom of the screen) and select Launch Admin Page.

The ColdFusion Administrator launches in a new Eclipse tab and prompts you for your administrator password (which is the one you chose during installation).

Once you’ve logged in, select Data Sources from the left hand menu. At the top of the screen there’s a form for creating a new data source. Enter “URLShortener” as the data source name, select Apache Derby Embedded from the driver dropdown and click Add.

You’re nearly there! In the form that you are now shown, type “URLShortener” in the Database Folder (same as the data source name), and tick the Create Database checkbox. Hit Submit, and your Derby embedded database is created at the same time as your ColdFusion data source name.

Overview of the problem

Are you still with me? Now that we have a development environment and a database, we’re ready to think about how we’ll develop our URL shortener.

URL shortening applications are all over the Internet these days. URL shorteners aim to solve the problem encountered when trying to use long URLs in an instant message, a Twitter message, or any other form of communication with limited characters. The basic premise of a URL shortener is to give you a unique short URL to their site, which, when clicked will redirect the user to the longer URL.

For example, to link to this SitePoint article “What’s New in ColdFusion 9″, with the following URL:

http://www.sitepoint.com/article/whats-new-coldfusion-9/4/

The service TweetBurner will give you this shorter URL:

http://twurl.nl/qiakd3

At just 22 characters, the shortened URL is less than half the length of the original 58 character link. And with longer URLs, the benefits are even more obvious.

Adding tables to the database

To create our URL shortening application, we’re going to need to create a table in our Derby database. We’ll call our table content and give it the following columns:

Column	Data type	Description
id	integer	Data
label	character(100)	-
text	text	-
link	text	The URL we are linking to
shortlink	character(20)	The short code that will identify our URL

There are some fields in this database that are not strictly necessary for a simple URL shortener, but we’re going to use them in a follow-up article to this tutorial, so we might as well add them now.

As we mentioned before, there’s no client or user interface for the embedded version of the Apache Derby database, so to create our tables we’re going to run a SQL script in ColdFusion. Open the file db.cfm in the web root of our ColdFusion Builder Project. It contains the following code:

Creating database... CREATE TABLE content ( id INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1), label VARCHAR(100), text VARCHAR(500), link VARCHAR(500) NOT NULL, shortlink VARCHAR(20) NOT NULL, CONSTRAINT shortlink_uc UNIQUE(shortlink) )

You can execute this code by clicking the Run icon in the toolbar - it's a white arrow in a green circle. This will launch the script in your default browser. It is also possible to launch the browser inside of ColdFusion Builder by switching to a tab at the bottom of the editing window. There will be a tab for every browser that has been detected on your computer.

After executing, you'll see the result of the query operation that we ran:

While there's nothing to specifically state that the operation was successful, it indicates that there were no errors, and shows the execution time and generated SQL code that was run, so we can safely assume that all is okay.

The application code

Take a look inside the ColdFusion Builder project and you'll see a couple of other .cfm files, and several .cfc files - one on the root directory, and one inside the /com subdirectory. Files ending in .cfm are regular ColdFusion template files. The .cfm extension tells the web server to pass them through the ColdFusion application server before serving them to the end user's browser. A file with the .cfc extension is a ColdFusion component. This is ColdFusion's equivalent to what is often called a class in other languages.

Application.cfc

The Application.cfc file in the root directory is a special kind of component which is run before each page request. It holds application-wide settings and has a set of special functions that are run when the application first fires up, before and after each request, when a user session is started or ended, and when an error occurs.

There is an Application.cfc file in the root folder of our ColdFusion Builder project. Open it up and you'll see it sets a couple of variables - the application name, and a timeout value - and has one function, onApplicationStart:

  

    

    

    

    

  
      returntype="boolean" output="false"  

      hint="Fires when the application is first created">

As we will have multiple files in our URL Shortener application, and they are all going to need to use functions in content.cfc, we're going to load that component into the application scope when the application starts. This means that on any page request, we'll be able to reference any of the functions inside content.cfc by prefixing them with application.oContent.

First, the form

Enough housekeeping - let's jump into some code. To allow our users to enter their URLs to shorten, we'll need a form. Open up add.cfm in the ColdFusion Builder project root, and you'll see a basic form.

At the top of the form is some code that is run when a variable called form.action is defined. Essentially, a function from our content CFC is run inside a loop until the loop's exit condition - the shortlink variable is not zero length - happens. We'll examine what's actually going on here in a moment. Skip down in the file and you'll see a standard HTML template with a little bit of ColdFusion conditional display code - checking for a variable's existence and if it is found, displaying it - and a HTML form to enter our URL to shorten. Fairly simple stuff.

  

  

  URL to shorten

The heavy lifting: generating the short link code

To generate our short URL, we're going to create a function which returns a random string of a predefined length from a pool of acceptable characters. I've added 63 possible characters - uppercase characters A-Z, lowercase characters a-z, digits 0-9 and the dash character (-). A six-character string made up of these characters yields 636 possible combinations: that's 62,523,502,209 URLs, which should be enough to keep us going for quite a while!

Open up Content.cfc in the /com directory under our project root to see this function (it's the very first one listed). You'll see that the function generateShowLink takes one argument, length, which is required but has a default value of 6, should it not be supplied:

This is the number of characters that will be generated for the shortcode. Should you wish to use more or fewer characters, you could simply pass a value for length into the function when it's called. In this code snippet we're also setting up a variable structure called local to store local variables.

First we set up a list of all allowable characters, then define our radix - that is, the total number of possible characters:

   

     

     

  
Then, after setting our return variable to an empty string, we're going to add random characters from that list in a loop:
   

   

   

   

   

     

     

         

     

  
   & listGetAt(local.chars,local.randnum)>   

   

Finally, return the newly generated short link to the calling code:
   

     

       

 
When we insert our link and short URL code into the database, we need to make sure that the short link value is unique in the database. To help with this, we made the shortlink column in the database unique, so if we attempted to insert a duplicate value, the database would throw an error. We're going to use this to our advantage.
The function in content.cfc that actually handles the insertion of data into the database is called insertContent. It takes one argument, link - the URL that we wish to shorten - defined at the top, and then initialises a local structure that will hold variables that we need to use locally in this function:
   

   

Next, inside an error-catching cftry block, we're going to attempt to insert the link and a short link code generated by our generateShortlink function. If the shortlink value is unique, the insert will be successful, and our insertContent function will return the new value to display to the end user.
   

   

   

     

     

    INSERT INTO   

      content(   

        link,   

        shortlink   

        )   

    VALUES(   

      ,   

         

        )   

     

     

     

    SELECT   

      shortlink   

    FROM   

      content   

    WHERE   

      id =    

  
What if the generated shortcode just happens to be one that's already been used? The function will hit the error-catching cfcatch block, where the result is instead set to an empty string:
     

         

         

      

   

  
The last thing the function does is return either the newly inserted short link, or an empty string:
   

    

In our add.cfm component, we are calling the insertContent function inside a condition loop:
   

   

This loop will continue to run, generating new values and trying to insert them into the database, until it is successful and the value returned is not an empty string.
The add.cfm template then sets the message variable to hold the newly generated short URL:
The message variable is displayed to the end user just above the form:
   

   

  #message#   

The last step - handling shortened URLs
The final piece of the puzzle is the code that actually accepts our shortened URL and redirects the end user to the real link. This code is inside index.cfm.
First, we use the built-in cgi variable to read the contents of the current request's query string, and the Replace function to remove the question mark at the beginning of the query string.
   

Because we're using the built-in development server, which is very basic, it's hard for us to generate cleaner short URLs - that is, URLs without a question mark in them. If you were building a URL shortening application that was going to be deployed on ColdFusion running on an Apache or IIS server, you would be able to remove the question mark from the equation.
Next, we retrieve the full link record from the database using the getLink function from inside the content.cfc:
   

Jumping back over to content.cfc, this getLink function performs a simple database lookup on the one required argument, shortlink, and returns the original link value:
   

     

     

     

    SELECT   

      Link   

    FROM   

      content   

    WHERE   

      shortlink =    

     

     

Finally, we take the link value returned from the database. If there's a valid URL there, we use a cflocation tag to redirect the user to this link. However, if nothing is returned - the value of link has zero length - then we're going to display an error message.
   

   

     

   

  Link not found.
   

Improvements
This example is very simple and there are a lot of ways you could improve it, should you wish. As a starting point, there is no validation of the input variable - it would be nice if the URL add form displayed a message if the entered URL was not valid. I'm sure there's much more you could think of too!
Stay tuned for a follow-up to this tutorial, where we'll expand on our URL shortener to include a rating widget.  For now, try your skills at our ColdFusion quiz, proudly sponsored by Adobe, to check how much of this tutorial you've absorbed.

What’s New in ColdFusion 9?

Kai Koenig — Tue, 14 Jul 2009 14:00:00 +0000

The ColdFusion 9 beta is finally here, and there’s plenty to get excited about. If you’re up to a challenge, test your knowledge of what’s new in ColdFusion with our quiz! What’s more, there’s a freebie up for grabs for the first 200 quiz contestants who enter their details – a ColdFusion evangelist’s kit, full of everything you need to know about what’s happening in the world of ColdFusion.

ColdFusion and the ColdFusion Markup Language (CFML) in general have recently gained significant traction, with not one but two alternative engines garnering interest from the open source community; now, interest is growing more, with the next generation of Adobe ColdFusion – formerly known as Centaur – made available as a public preview release. This pre-release version of ColdFusion 9 has unveiled a very interesting set of new features.

Among these are improvements to various tags, the CFScript language and the overall syntax and coding style, the PDF subsystem, and Ajax components. Probably the two most publically discussed and awaited features are the ColdFusion IDE ColdFusion Builder (also known by its codename, Bolt) and ColdFusion 9′s new ORM (object-relational mapping) system. We’ll be taking a look at some code examples – if you’re keen to follow along, you can grab all these here, and view demos in action. Let’s dive in!

Caution! The features described in this article and all code samples are based on the ColdFusion 9 pre-release version available on Adobe Labs at the time of publishing. Please understand that Adobe might change or even remove features of pre-release software at any time – so some features in this article may be dropped from the final release.

A big kudos goes to Kay Smoljak for contributing the sections and examples on ORM and Ajax features to this article.

ColdFusion Builder

Let’s start this article off with a look at one of the most visible features of the upcoming ColdFusion 9 release: ColdFusion Builder. Although ColdFusion Builder 9 is a stand-alone product and separate from the ColdFusion 9 server product itself, we think it’s one of the most important moves Adobe has made in the last few years. ColdFusion veterans might remember back to the good old days of Allaire’s ColdFusion Studio, which was the last commercially available and dedicated ColdFusion IDE.

ColdFusion Builder has been created on top of Eclipse, the well-known development framework that powers dozens of popular IDEs. Adobe’s made good use of Eclipse in the past – Flex Builder (now called Flash Builder) and Flash Catalyst are both Eclipse-based tools.

The IDE presents itself with a typical Eclipse-like workspace consisting of various views. In the figure below, you’ll see a common development setup comprising a project navigator on the left, code views in the center, and multiple helper views such as outline, RDS database and file server views, and log file access to the right.

It’s possible to set up multiple servers in ColdFusion Builder so that one could directly interact with development, staging, and production environments. The code views also offer toolbars for quick access to commonly used ColdFusion tags, HTML, and CSS features.

ColdFusion Builder includes a line debugger, which developers already working with Eclipse will become familiar with in a very short amount of time. It’s a feature Adobe had already introduced in ColdFusion 8, but now springs to new life with a dedicated IDE catering for the debug process. Here’s the debugger in action.

The third set of features we’d like to introduce here are the extremely helpful code and content assistance, together with syntax checking. Any good IDE should include syntax highlighting and code completion as a matter of course, but Adobe has added useful support for instantiating ColdFusion Components (CFCs) and introspecting CFC methods, which you’ll see in action in the figures below.

ColdFusion Builder also provides an ongoing syntax analysis of your code by parsing the files right there in the IDE. This feature alone provides a massive boost in productivity – there’s no more need to run the page in the browser anymore to see if there was a syntax error in the ColdFusion code.

Of course, there’s more to ColdFusion 9 than a shiny new IDE. Let’s move onto some server features and practical examples.

Language Specification Enhancements

Let’s examine some of the changes and improvements to the language of ColdFusion itself. The first of these improvements surrounds CFScript, and the changes can be best described as upgrading CFScript to be a first-class citizen in ColdFusion 9. CFScript is a way to write CFML code in a manner that resembles JavaScript. Unfortunately CFScript never supported the full language features of ColdFusion, and was quite limited in a various ways.

In ColdFusion 9, we’re now able to code ColdFusion Components entirely in CFScript, and that we can run SQL queries from CFScript. To compare, let’s see an identical logging component written and called in both CFML and CFScript.
Using CFML, let’s create a simple logging component:

  

  
   returntype="logWithTags">  

    
      type="string" required="no"/>  

      

      

    

  

  
   returntype="void">

Here’s how we’d invoke the component and write a message to that log:


  logFile="LogTestDeleteMe" returnvariable="logger" />  

    


  message="Testing out the new logger with CFML." />

In ColdFusion 9, we’re able to use CFScript for this purpose. Here’s a logging component written in CFScript, which is functionally identical to the above component:

component  

  {  

    public log function init (string logFile="customLogger") output="false"  

      {  

      variables.logFile = arguments.logFile;  

      return This;  

      }  

    public void function write(string message) output="false"   

    {  

    writelog(text=arguments.message, file=variables.logFile);  

    }  

  }

And in CFScript, we’d invoke it like so:

  

  logger = new log('LogTestDeleteMe');  

  logger.write("Testing out the new logger.");

Let’s explore how to execute a database query from ColdFusion 9′s new CFScript engine. If you’re a Java developer, you’ll see how similar the structure of the code is to writing Java code for querying SQL databases via JDBC. The argument passed in the method setDataSource is a named reference to an SQL database that can be set up in ColdFusion’s administration tool:

  

  query = new Query();  

  query.setDataSource('cfartgallery');  

  query.setSQL("SELECT * from artists") ;  

  results = query.Execute().getResult();

Other language enhancements include a cffinally tag for exception handling, the ability to nest cftransaction tags, assignment chaining (a=b=c=d, and so on), and support for ternary operators such as a = (b.

ColdFusion 9 also offers new integration with PDF documents and spreadsheets. The updated PDF subsystem provides new tools for extracting text from PDFs, and optimizing them. The latter is particularly interesting: PDF documents are often full of bookmarks, comments, JavaScript, and other information, but in many use cases it’s best to strip out this extra data.

Extracting text from a PDF document is as simple as using the cfpdf tag’s new action, extracttext. Here, we’ll extract the text from a test document:


  source="#ExpandPath('./testdocument1.pdf')#"   

  name="xTestdoc"  />

Similarly, using the new optimize action, we can remove the bookmarks and comments from a PDF, and write the results out to a new, optimized file:


  source="#ExpandPath('./testdocument1.pdf')#"   

  destination="#ExpandPath('./testdocument1_optimised.pdf')#"  

  nobookmarks = true  

  nocomments = true />

Another very interesting opportunity to integrate with external data formats has been created with the cfspreadsheet tag. It provides a way to interact with Excel documents of both .xls and .xlsx types, and enables developers to read data from and write data to spreadsheets. The code below reads data from an Excel 2007 document and outputs the content in a table:

   

   

   


    sheet="1" query="excelQuery" headerrow="1" />   

   

   

     

       

       

       

     

     

     

       

       

       

     

     
First Name Last Name Words written
#firstName# #lastName# #wordsWritten#

First Name	Last Name	Words written
#firstName#	#lastName#	#wordsWritten#

ColdFusion’s SpreadsheetAddRow function allows you to create a new entry in an Excel file. ColdFusion 9 also supports OpenOffice spreadsheets:

`ColdFusion ORM`

One of the most exciting new features in ColdFusion 9 is ColdFusion ORM. ORM stands for object-relational mapping – a concept in object oriented programming where code objects are mapped to relational database tables for persistent storage. The ORM lets you access and update data through the application using the object model, without you needing to know anything about the details of the underlying database structure. The idea is that the ORM takes care of all the mundane, rote tasks for the programmer: scripting tables, writing CRUD operations (create record, update, and delete – the basic building blocks of most applications) and the like, leaving them to focus on interesting and challenging programming tasks. Other advantages of an ORM include database vendor independence and built-in caching features. Sounds good, right?

ColdFusion developers writing object oriented applications have been able to use ORMs in the past with the help of external frameworks, Transfer and Reactor being the two best known. However, ColdFusion 9′s new built-in ORM features are based on Hibernate, an open source ORM library that has been around in the Java world since around 2004. It’s popular, tried, and tested, and seeing as ColdFusion is based on Java, an obvious choice for the ColdFusion team.

So how does it work? There are two ways to work with ORM systems: either you create your data objects in code, and let the ORM create the database tables for you, or you start with the database, and have the data objects built for you. ColdFusion ORM lets you work in both of these ways.

As a very basic example, if you would like ColdFusion to create your tables for you, you’d enable ColdFusion ORM in your Application component by setting some basic variables. Let’s say you were using a MySQL data source that had been set up in the ColdFusion Administrator as sampledb:

Next, you create your CFC, setting the value of persistent to true to map the CFC to a database table. This example CFC has two properties – name and email:

Now, you can use the ORM functions such as EntityLoad and EntitySave to retrieve and update that data.

When your application is run, if that table does not exist in the database, it will be created. If, on the other hand, you already have a database structure and would like ColdFusion to generate your code, you’re going to need ColdFusion Builder to inspect your database and generate code. If you’d prefer to maintain some control over the way ColdFusion creates that code, that’s okay too – you can create your own base templates to dictate how the generated code should be arranged, or download and install another’s templates.

`Ajax Features`

One of the more exciting updates to ColdFusion 8 was the addition of new Ajax components, making the power of the ExtJS and YUI JavaScript libraries available to the ColdFusion programmer via a few simple tags. Now, in ColdFusion 9, the Adobe team has upped the ante, upgrading all of the libraries (including bringing ExtJS from version 1.0 to 3.0), which brings a number of enhancements across the board.

In particular, the datagrid and accordion components have been updated, and new components include a multiple file upload tool, a progress indicator widget, a media player control, and a Google Maps widget.

At its simplest, the multiple file upload component created with the new cffileupload tag requires only the url attribute, which specifies the processing script that will handle the file upload on the server:

Below, you’ll see how that upload component appears.

There are many configuration options available, including limiting the size, maximum number, and type of files to be uploaded, as well as the button labels, size, and color of the component.

The new cfmediaplayer tag plays video files in the now ubiquitous Flash video format (.flv). Again, a very simple implementation needs only one parameter: the location of the file to play:

Configuration options include height, width, the ability to define borders and a background color, choice to display video controls and allowing the video to be played full screen, and even JavaScript functions to be triggered on load, on start, and on complete. Here’s how a basic media player appears:

One very useful Ajax component is the new cfmap widget, which embeds a Google map. The Google Maps API key for the domain can be specified either in the ColdFusion Administrator, in the site’s Application.cfc file, or imported at runtime via the cfajaximport tag. It’s as easy as this:

This produces the following map:

You’ll notice cfmap has an opening and closing tag. Inside the tag pair, you can place cfmapitem tags to represent other items. Let’s add one to point out Adobe’s head office:

    

    

  
   address="345 Park Avenue, San Jose, CA, USA"    

   tip="Adobe's Head Office"/>

Now, your map will display the additional marker, as shown below:

Altogether, the preview release of ColdFusion promises to be a highly interesting piece of technology for web developers. There are so many more new features and improvements to the product that we found it impossible to discuss each in detail, or even mention them all here, but you’ll find plenty of information about ColdFusion 9 in the new Administrator’s Guide and CFML reference documentation. The ColdFusion 9 and ColdFusion Builder betas are available, too – now’s the time to start work!

ColdFusion 9′s packed with new features and improvements. Test your knowledge of what’s inside the new ColdFusion with our quiz! Don’t forget, the first 200 participants who fill in their details will receive a shiny new ColdFusion evangelist’s kit – perfect for convincing your boss to give ColdFusion a try!



The release of ColdFusion 9…
Kay Smoljak — Thu, 04 Sep 2008 15:43:13 +0000
…well, the shirt anyway. If you’re eagerly anticipating ColdFusion 9 – codenamed Centaur – you can now get the unofficial tshirt. User groups can get bulk orders with their name on the back. Pity it’s white though! hat tip to Ben Forta.
The biggest news this week was that Adobe have finalized their educational licensing and ColdFusion 8 is now available to students and educators free of charge. Government agencies in the US can get a 20% discount on ColdFusion 8 at the moment as well.
Coding
A couple of security posts this week – hat tip to Steve Bryant’s CF_BlogPicks for these links:
Joshua Cyr reminds us to make sure we’re not giving away too much information on our production servers
Jason Dean continues his security series (9th installment) with Request Forgeries and ColdFusion
In more general code-related news, Stephen Withington has out together a big list of Java Servlet equivalents to CGI scoped variables – so instead of CGI.PATH_INFO for example, you can use getPageContext().getRequest().getPathInfo(). The comments on the post explain a little about why you might find the Java Servlet alternatives more useful.
   
Paul Marcotte explains his approach to test driven development in detail – part 1 (Application Structure and Apache) and part 2 (MXUnit, ColdSpring and ColdMock) are available.
Ben Nadel, always one to share his learning experiences, has posted about his first experiences using ColdFusion 8 secure CFFTP. Brad Wood explains what the de() function actually does. And Raymond Camden still hates CFFEED.
Frameworks
Mach-II news: Matt Woodward reports that the alpha of the Mach-II Dashboard has been released. According to Matt, the dashboard “gives you a ton of insight into and control over your Mach-II applications, letting you reload the application or individual modules, reload the base or child ColdSpring bean factories, manage logging, and manage caching.”
An on the Fusebox front: Sean Corfield reports that Jeff Peters’ book How to Drive Fusebox 5.5 is now available for purchase. Being a Fuseboxer myself, I’ve ordered my copy already – Jeff’s previous Fusebook books were great.
Community
Brian Rinaldi took a week off his Open Source Update last week – I don’t know if you missed him, but I certainly did. This week he’s back with four new projects, 12 updates, and a whole ton of announcements, tutorials, presentations and reviews.
After a bit of a hiatus, I’m getting back into the swing of my CF-TALK mailing list roundups. Last week’s summary included discussion threads on SQL Injection, Web Services, Academic Licensing and Career Advice.
A Wee Dram of Scotch – the mini Scotch On The Rocks conference being held in London on September 25 – now has a full program and is open for registration (hat tips to Andy Allan and Sean Corfield). With the stars in the lineup and at only £10, I dare say it’s going to sell out quickly.
Alternative CFML Engines
Gary Gilbert has posted his impressions of Railo 3, after meeting Gert Franz and Michi Streit at the Munich CFUG. Gary was impressed by the “strict” variable scoping setting in the Administrator, the Amazon S3 resource, and the extension framework.
Michael Sprague has released a beta of CFjqAjax, a library of custom tags to replicate ColdFusion 8’s Ajax UI controls CFGRID, CFWINDOW, and CFTOOLTIP with jQuery equivalents. This is great news, not only for people who prefer to work with the jQuery JavaScript than ExtJS or YUI… but also for those using alternative CFML engines like Railo and Open BlueDragon.
Okey dokes kids, that’s all for now. Got a tip? Email kay at smoljak dot com, leave a comment or tag at delicious.com with for:kay.smoljak. Til next time…
  
  



All’s Quiet on the CF Front…
Kay Smoljak — Thu, 28 Aug 2008 14:09:57 +0000
This week was strangely quiet. Nothing much on the frameworks front; Open BlueDragon and Railo kept to themselves. Hmmm, looks like everyone is heads down coding… let’s see what they’ve got for us.
Code n’ Concepts
Adobe have released a technote briefly demonstrating how images can be streamed. And if you’re working with CFIMAGE, Scott Pinkston reminds you to make sure you apply all the patches lest you find yourself pulling your hair out unnecessarily
Ben Nadel’s OOPhoto project is still progressing – the latest installment is Encapsulating Form Processing In The Service / Facade Layer
Raymond Camden answers a reader’s query about populating tooltips with a CFC and beats up on the CFFEED tag
Following up from his ruminations on Business Logic, Doug Boude attempts to define just what is Application Logic
Doug Hughes introduces the CFANT project, a toolkit for scripting remote CF deployments
The MXUnit unit testing framework has been updated to 1.0.2
Are you a fan of nested sets to represent tree structures in your database? Nested Set Trees – a ColdFusion library for managing the various operations involved – has hit version 0.8.
   
SQL Injection attacks still bugging you? Simon Whatley has posted on how to fix an SQL Injection hack, and also how to protect against a malicious attack in the first place (hat tip to Steve Bryant). You know what they say about prevention being better than cure… Peter Boughton has released an Eclipse IDE plugin called QueryParam Scanner which looks through code to find and report on queries with unprotected input parameters. No excuses now – lock down that code!
Conferences
Some bad news UK developers: UK conference CFDevCon has been canned.
Some good news for UK developers: A Wee Dram of Scotch – a one day conference from the Scotch on the Rocks team – has been announced for September 25 in London (hat tip to Andy Jarrett).
While we’re on conferences, the four tracks for cf.Objective() 2009 have been announced (hat tip to Nic Tunney).
So that’s it? Really? Tell me people, did I miss something? Leave a comment, tag for:kay.smoljak on delicious.com or email kay at smoljak dot com with all the juicy goss.
  
  



10 Questions for Isaac Dealey on the OnTap Framework
Kay Smoljak — Sun, 24 Aug 2008 23:50:02 +0000
Isaac Dealey is the author of two frameworks: onTap and more recently, an ORM (object relational mapper) called DataFaucet (subject of a future framework interview). Here’s his answers to my 10 framework questions.
See other framework interviews: Geoff Bowers on FarCry, John Farrar on COOP and Mark Mandel on Transfer ORM.
1. Hi Ike! Give us your elevator pitch: summarize the essence of onTap in a sentence or two.
Sales Pitchy Version: The onTap framework does for ColdFusion what ColdFusion did for the web: simplify a lot of powerful tools.
Not so Sales Pitchy Version: The onTap framework is an SOA approach to ColdFusion development.
2. Let’s dig a little deeper: tell us more about the main features.
Version 3.2 has converted all its config files from flat CFML includes now to CFCs and includes a new IoC Manager. The IoC Manager and the Plugin Manager provides a structure for developers to distribute or sell pluggable, smartly integrated applications and services that can be installed within a browser. In the not too distant future, the framework site will host a webservice which allows those “plugin” applications to be installed directly from within the framework in much the same way that add-ons can be installed in Eclipse or FireFox 3 without leaving the IDE.
   
If that sounds intimidating, don’t worry. None of that is actually necessary for developing applications with the onTap framework. The framework itself is agnostic about OO, the same way that the Fusebox framework is agnostic. You can choose to develop your application in an “extreme OO” manner, using an IoC framework, etc. or you can just build pages if that’s your preference. My preference is for the OO/SOA approach.
The framework includes a powerful XHTML library: a powerful and extensible templating engine which gives you access to a variety of form building and Ajax tools.
I use these XHTML tools in combination with a unique core architecture I’ve been calling “tiered inclusion”. Where Fusebox has circuits and fuseactions, the onTap framework has a “process”, which resembles and actually maps to both a URL and a file path. This tiered inclusion also provides some additional directory-based hooks for powerful branding/customization features as well as a host of very comprehensive internationalization (i18n) features for anyone who needs or wants them.
And that’s not even getting into a variety of other odds and ends you’ll find in the framework like content caching, section-508 compliant Ajax widgets, an XML-based rule-manager tool for providing powerfully configurable business logic that users can manage (not found in other frameworks), etc.
3. How did onTap come about and what was the reason for creating it? How are you involved?
I’m the original author. About the time I started working on the tiered inclusion technique, I had been doing a lot of work with Fusebox 3. Sure it was a decent framework, and initially I was a big fan of it… over time I found myself growing increasingly disenchanted by the amount of repetition involved in the switch files in Fusebox 3.
The tiered inclusion concept was something that just occurred to me spur of the moment one day and I worked on it for a long time to perfect it. For myself, it’s always provided an excellent way of reducing the amount of code I write. The rest of the framework came later and has always just been an endless pursuit of tools to make my own development work easier – if I found a way to create a generic tool that would be useful later, I included it in the distribution.
4. When should a developer seek out onTap? What has it got going for it?
The onTap framework’s biggest strength is in its ability to allow seamless branding and customization as well as seamless, automated integration between plugin applications (both using the same techniques).
I worked for a lot of ASP companies over the years and one thing that has been a consistent problem at every ASP I’ve worked for has been client customization requests. Clients invariably want tools the system wasn’t designed to provide and then finding a way to provide them is consistently problematic for the company providing the service, often actually hurting the company financially. The onTap framework provides a comprehensive set of tools that work very well for mitigating the problems caused by implementing client customization requests.
5. What are the pre-requisites for using onTap? Is there any prior knowledge that would help new users? Does it use any other frameworks that could simplify or complicate things?
Knowing some ColdFusion obviously would help! The only real requirement is ColdFusion 7 and it should run on both Windows and Unix operating systems. I haven’t tried with more recent versions of BlueDragon or with Railo yet. It doesn’t require any additional frameworks, although it does include built-in integration for ColdSpring or Lightwire if that’s your preference.
The core architecture behind the onTap framework is honestly not very complicated and is intentionally designed to be very simple to use, however it is unlike most other ColdFusion frameworks in its approach. So if you come to it expecting it to behave just like Mach-II, Model-Glue, ColdBox or even FuseBox you might have to unlearn some complexity to understand how simple and powerful the onTap framework is.
When I work on my own projects, I spend no more than a few minutes on things that normally, even with a good framework like ColdBox, would take several hours of my time. I spend those extra hours working on new problems instead of working on problems that I’ve already solved a bazillion times, like laying out or validating a form. And when I work on projects at my day job I essentially consider much of my time spent working as “time wasted” because I know how much faster things could be done.
6. What sets onTap apart from other frameworks?
Three things especially:
 - Its SOA Approach to ColdFusion development
 - Powerful tools for customization and branding (very useful for ASPs)
 - Its simplicity
Actually something I find interesting is that several years ago I had done a comparison of several ColdFusion frameworks – there weren’t very many at the time, so I had just Fusebox 3 and 4, Mach-II and the onTap framework. At the time I was really disenchanted by the extra work required by the other frameworks, particularly the many, many lines of XML required for Mach-II.
In the intervening years, not just Mach-II and Fusebox have adopted my approaches, but other frameworks like ColdBox have cropped up in various places all touting as their advantages techniques that I’d been using for a long time. I’m not just saying this to pat myself on the back (in spite of the fact that I do take pride in it), but to point out that nearly everything that’s in the onTap framework has always been “ahead of its time”. I think that should speak to the longevity of the framework, which I know a few people have worried about.
In truth I like to think that the onTap framework functions in many ways a lot more like ColdFusion than most of the other ColdFusion frameworks that have been created in recent years.
7. Are there any great examples of onTap “in the wild”? 
I have to be honest here and say nobody’s informed me of any yet. I really wish I could say “ahh yeah, XXX Bank is using it”, but I can’t.
Several years ago I implemented a solution using it for a defense contractor called Raytheon. I hesitate to say that’s an example of the framework in the wild because it was such an early version.
I’m excited to get the news though!
8. What about licensing, community, support and documentation? 
It’s released with an OpenBSD style license, which is a little less restrictive than LGPL2 in that, not only are you allowed to create commercial software using it (lord knows I’ve had my own plans), but you can also encrypt your own software based on the onTap framework if you want to. It only requires that you include the notice that your distribution includes the onTap framework and that it’s not endorsed by the framework authors (which as of today is just me).
I’m currently working rather hard to try and grow the framework community. I’m trying to find better ways to encourage feedback and participation. I’m just not good at the marketing and people skills. I am however very interested in growing a more active community around this framework like the Fusebox or FarCry communities which have actual dev. teams and active forums and mailing lists. I’d like the framework to have a dev team at some point, not just me. I’d like for it to include code reviews / critiques and code contributions from other members of the community. I just recently published a blog about this specifically asking for people to write about their experiences with the framework, good bad or ugly.
Documentation for the framework has always been… well, verbose. I have actually removed some of the documentation in this latest release because I found that not only was a lot of it not read, but I’d had a number of developers over the years voice … well they weren’t complaints, but they would say things like Jeff Peters from the Fusebox community when I met him at cf.Objective had related an anecdote about having looked at the documentation a few days before and having a conversation with someone else in which the phrase “Do I have to read ALL this?!” was used.
The author of Model-Glue, Joe Rinehart once made a comment on the cf-talk list to the effect of “thanks for setting the bar so high for documentation” because he found my documentation to be so thorough (read LONG).
9. What’s coming up in the future for onTap?
Right now I’m working on getting it back onto its own domain. I just registered tapogee.com … Soon I hope it will be hosting the webservice I mentioned before for instantly finding and downloading plugin applications. My hope is that with a more active community there will be many plugin-based services and applications that can all work together to create a suite that truly leverages the collective talents of the ColdFusion community at large in a way that’s not been seen with other frameworks thus far (yes even FarCry, I’m that bold). Work less, accomplish more.
To that end I’m also considering self-publishing a small book on how to develop applications using the framework, and possibly t-shirts and other guerilla-marketing techniques.
10. Where can people find more information about onTap?
http://on.tapogee.com and check out the framework blog on RIAForge.
  
  



The Week In ColdFusion: 13-19 Aug: And amongst the Gurus, an ArgumentCollection did break out
Kay Smoljak — Thu, 21 Aug 2008 15:50:01 +0000
So… did ya miss me? I had an awesome holiday, and have come back to an overflowing feed reader. Although I may touch on some of the big things that happened while I was away, I’m going to concentrate on the current week – otherwise this post would take you an hour to read and me all day to write!
Community
It was quite a while ago now that Adobe announced that ColdFusion would become free for educational institutions. Brad Wood has posted a call to the community to help make that push successful by helping to develop curriculum for teaching ColdFusion. There’s some things already happening by the sound of it, so If you have an interest in the academic sphere check Brian’s post out.
Conferences
Although conference season seems to be slowing down, one of the biggest conferences – Adobe MAX US, to be held this year in San Francisco – is till on the horizon. Ben Forta warns that early bird pricing ends on August 31st.
   
Just because the big conferences are over doesn’t mean that conference-style learning can’t continue. I’m a big fan of BarCamp – user-generated “unconferences” – which are held in hundreds of locations around the world. Mike Henke attended his first ever BarCamp recently and wrote about the experience. If there’s a BarCamp on your area, it’s definitely worth getting along – and if there’s not one close to you, maybe that’s an opportunity to start one!
Resources
A new article has been published in Adobe’s ColdFusion Developer Center on High availability clustering in ColdFusion. Mike Brunt explains how enterprise developers need to consider clustering right from the start when planning applications.
One of the things that happened while I was on holiday was that US-based marketing services company Broadchoice expanded their engineering team, already overflowing with CF gurus such as Sean Corfield, Raymond Camden and Nicolas Lierman, to include both Brian Kotek and Joe Rinehart. This super star team has started a new collaborative blog called ArgumentCollection. There’s already a whole stack of posts including ones on Transfer, ColdSpring and Model-Glue, so I expect big things from this corner of the web.
Frameworks
The big news for Fusebox right now is that Sean Corfield has officially passed the reins over to Adam Haskell for development of the Fusebox core files. Thanks are due to Sean for the phenomenal job he has done with the Fusebox 5 releases thus far despite his no-doubt massive workload. I’ll look forward to seeing the core files develop further under Adam’s stewardship.
Alex Lloyd has released a Fusebox lexicon for Transfer (hat tip to Nick Tong).
ColdBox 2.6.1 (final release) is available for download (hat tip to Russ Johnson).
ColdFusion on Wheels, the CF community’s response to Ruby on Rails, has been updated to 0.8, adding Oracle support amongst other features and bug fixes (hat tip to Ben Forta).
On the FarCry CMS and framework: Brad Wood has posted about his first impressions of version 5, and Geoff Bowers writes an explanation of how meta-data is used to define configs in XML Configs Suck. Matt Woodward confirms that FarCry will run on Open BlueDragon, and Michael Sharman posts about the process he used to get FarCry running on Railo 3 (Michael also gets enthusiastic about Railo generally).
Code
Ben Nadel has been busy exploring the world of object-oriented ColdFusion. I’ve missed a whole stack of great posts but you can always view where the OOPhoto application is up to on Ben’s site. He doesn’t have a separate category just for OOPhoto posts (hey Ben, how about it?), but it’s not too hard to find them working back from the homepage. Also catching my eye on Ben’s blog is his tip on extending the functionality of encrypted Application.cfm files.
Anuj Gakhar has updated his CRUD application using ColdFusion 8’s ExtJS-driven CFGRID. There are a number of enhancements based on reader feedback.
Scott Stroz has demonstrated a cool use for CF8’s QueryConvertForGrid() function… a use that doesn’t involve grids at all.
Whew, that wasn’t so bad, was it? Posting will resume as normal now – and I have a new framework interview almost ready to post – so if you have any tips, please email me (kay at smoljak dot com), flag your bookmarks in Delicious (which has recently undergone a major and very cool redesign) with for:kay.smoljak or leave a comment here. Until next time!
  
  



The Week in ColdFusion, 2-8 July: Object-oriented CFML for fun and profit
Kay Smoljak — Fri, 11 Jul 2008 00:33:22 +0000
In the last few weeks, the number of code-related blog posts in the ‘ole CFBlogosphere has skyrocketed – which is just the way I like it. This week I found lots of good material on writing object oriented code.
This bumper roundup will be the last that I’ll be posting this month – I’m off to Europe for a three week holiday in Poland, Slovenia, Italy and Germany. It’s my first time away in nearly 7 years – but of course, I’ll be thinking of you all… and many thanks to Mike Henke for sending me something to read on the plane!
Code – objects ahoy
Ben Nadel continues his adventure into learning object oriented programming with More Thoughts On MVC, OOP, And Form Submissions In ColdFusion and then OOPhoto Prototype – Understanding The Interface Before Defining The Domain Model. If you’re interested in OO, you will probably want to look into an ORM or object relational mapper framework to take some of the tedium out of creating objects. Bob Silverberg has written a series of posts on how he uses Transfer ORM. There’s now six parts, and they make an excellent read (hat tip to Sean Corfield):
   
How I Use Transfer – Part I – Introduction
How I Use Transfer – Part II – Model Architecture
How I Use Transfer – Part III – Abstract Objects
How I Use Transfer – Part IV – My Abstract Service Object
How I Use Transfer – Part V – A Concrete Service Object
How I Use Transfer – Part V.1 – A Comment and Response
If you’re writing OO code already or are using a CFC-heavy framework, you may have been affected by the ColdFusion 8/Java 6 “classLoader” bug, which can affect startup times. Brian Ghidinelli did some experiments on a model-glue application and suggests that the bug is less prevalent on “cold” restarts (restart of CF completely) versus “warm” application reinitialization. Useful information for anyone having issues with this bug!
But wait, there’s more… a TON more:
The cfSearching blog includes a handy code snippet for generating sample images of all the fonts available in your JVM – meaning fonts that are available for use in CFDOCUMENT, CFREPORT and in image generation functions. Good to know!
Interested in Lucene, the open source Java search engine? Sami Hoda has written two posts on using the Seeker wrapper for Lucene – ColdFusion & Lucene: Installing Seeker, which slipped under the radar last week, and now ColdFusion & Lucene: Running the Demos. Lucene is an Apache project and makes a good alternative to Verity for powering CFML site search
Doug Boude (rhymes with loud, ok?) explores basic security in Fusebox 5.5 – the flavor without XML controllers. As is often true of blogs posts, there are a couple of interesting comments on the post.
Raymond Camden’s “Ask a Jedi” series this week includes answers to questions about sorting a multi-dimensional array, datefields and masks, and ColdFusion.Ajax.SubmitForm
Nic Tunney and Mike Henke both posted lists last week of “under-utilized” features – this week Simon Horwith adds an extra two underutilised CFML functions: setVariable and structAppend
Steve Bryant has posted an introduction to writing unit tests with CFUnit
Kai Koenig often writes and presents about internationalization issues – this week he explains away the mystery behind some characters specific to the German language
Michael Sharman reminds us Don’t forget the ColdFusion site-wide error handler
Sami Hoda  posts information on new tools for session scope lovers – I didn’t realize people were so passionate about scopes!
Sean Corfield explains StructCopy
Community
A heads-up from Kristin Schofield, Adobe ColdFusion product manager about the online eSeminars that Adobe run each week. As well as those run from the US office, Adobe also run eSeminars from the Asia Pacific office, which anyone can attend.
Raymond Camden has had a lot to say – and mostly not positive things – about the Adobe ColdFusion certification process in recent weeks. This week he has posted what he says is his last post on the topic: My last post on Adobe Certification. Andy Allan has also posted his views as an Adobe certified instructor.
CFConversations, the new podcast put together by Brian Meloche, has now hit episode 6, an interview with Michael Smith of Teratech.
And for something totally bad-ass: Critter Gewlas has gotten an old-school ColdFusion logo tattoo – now that’s commitment!
Alternative CFML engines
From Matt Woodward over at the Open BlueDragon camp comes a screencast on how to integrate BlazeDS into OpenBD to allow Flex remoting.
The licensing of open source projects is a huge topic, and one that has only recently become relevant to much of the CFML community. Sean Corfield points to two helpful summaries of open source licenses, one written by Pete Freitag some time ago and another more recent (and more in-depth) article by Grant Skinner. There’s been a bit of discussion about new licensing for the ExtJS libraries that are included in ColdFusion 8. Sami Hoda has posted about the issue – and there are some excellent explanations in the comments.
However, not everyone is jumping to open source alternatives: David Tucker has written an article for O’Reilly’s Inside RIA about why, after evaluating all the options available to him, he chose to purchase a license of Adobe ColdFusion (hat tip to Ben Forta). He makes some good points!
Finally, if news of my upcoming trip makes you envious, how about a ColdFusion cruise? RIA Adventure is billed as networking event – a cruise through the Bahamas with like-minded ColdFusion, Flex and RIA developers, but without speakers or sessions. Organised for February 2009 by Joshua Cyr, this cruise looks like a ton of geeky fun – and Jim Priest has even written a theme song.
That’s all for now, folks… keep coding and I’ll talk to you all in August.
  
  



The Week In ColdFusion: June 25-July 1: An unconference, a new book and a boatload of code
Kay Smoljak — Thu, 03 Jul 2008 15:07:01 +0000
Last week there were lots of announcements and the odd bit of controversy in the ‘ol CFML blogosphere… this week, not so much. However, I do have some tasty code posts for you and some even tastier open source news – bon appetit!
Code
Interested in learning object-oriented programming? Join Ben Nadel as he builds a photo gallery application using OO techniques – and knowing Ben’s hands-on learn-as-you-go blogging style, this will be comprehensive!
Nick Tong shares a code snippet to export the contents of a table into a CSV file, using the Java StringBuffer
Rupesh Kumar from Adobe’s engineering team in India discusses the “EvalAtPrint’ attribute in the CFDocumentItem tag, new in CF 8.0.1
Troy Pullis shares some helpful checks to test your code’s vulnerability to XSS (cross site scripting) attacks (hat tip to Steve Bryant)
Nic Tunney posts his top 6 underused ColdFusion functions (hat tip to Mike Henke) – ListQualify() anyone?
Coding, debugging and testing tools is an important topic that all too often gets overlooked. The latest Fusion Authority Quarterly Report is all about development environments, and has an excellent set of articles on setting up and using Subversion, as well as the various development platform and IDE options available to the CFML developer. In the same vein, Mike Henke posts his top 6 underused shortcuts for CFEclipse, and Nathan Mische announces the release of ColdFire 1.2, the ColdFusion extension for Firefox’s Firebux debugging extension. I’m embarrassed to say I haven’t used ColdFire yet, but that’s something I intend to remedy this week.
   
Community
The Adobe MAX conference (US) web site has launched (hat tips to Ben Forta, Sean Corfield and Raymond Camden) with 28 ColdFusion sessions – as Sean points out, that’s a good amount compared to the coverage that some of the other Adobe products get.
Raymond Camden is asking for help in fleshing out the ColdFusion Cookbook web site. Do you have a question (preferably one with an answer)? Submit it and you could win a book. Ray also has posted some interesting comments on certification and memorization. And, always one with his fingers in multiple pies, Ray has also announced that he will be leading a ColdFusion ‘unconference’ at the Adobe MAX conference. That’s an interesting approach for Adobe to take and I think it could work out really well – we had a series of CFCAMP barcamp-style events with Adobe’s help in Australia last year, and they were a huge success.
John Beynon thinks there should be a “staging” license of Adobe’s ColdFusion server. What do you think?
Sammy Larbi has some more advice for the ambitious developer: if you want to be well known, release your code
John Farrar’s ColdFusion 8 book is now shipping! It’s available straight from the publishers in paper or PDF format, or through Amazon
Open Source
Brian Rinaldi’s Open Source Update has been going out weekly now for over 2 years! Congratulations Brian and thanks for keeping us up to date with all the good open source stuff. This week, two new projects and four updates, as well as some useful articles on Transfer, varScoper, and ColdFire. Also this week, Brian has moved his blog to Mango, the fairly new open source blogging engine from Laura Arguello. I’m using Mango in some commercial jobs right now and it’s a very sophisticated piece of software.
ColdBox announced earlier this year that they were going to move to a Professional Open Source Software project. Rob Gonda has announced that as part of that transition, partnerships have been announced with several companies to offer ColdBox training and curriculum development.
Railo 3.0 beta 2 has been released, with several improvements which Michael Streit explains on the offical Railo blog. Barney Boisvert talks about the significance of the array and struct improvements, and Raymond Camden points out the new variable scope handling options.
Matt Woodward has posted a seven minute screencast which shows how to build an Open BlueDragon WAR from the source code on OSX.
That’s all for now. If you have a tip for me, email kay at smoljak dot com, leave a comment or tag your links in del.icio.us with for:kay.smoljak. And remember: a CFFUNCTION a day keeps the .NET away…
  
  



The Week in ColdFusion: 18-24 June: CFML, Fast and Furious
Kay Smoljak — Fri, 27 Jun 2008 01:58:25 +0000
One of the big topics this week has been the announcement of the CFML Advisory Committee at CFUnited. This group, headed up by Sean Corfield, includes members of the Adobe ColdFusion community and the Railo community, but notably no one from the Open BlueDragon camp. Ben Forta has posted his thoughts on the committee, and a dialogue of sorts between Ben and Alan Williamson from Open BlueDragon resulted in the comments. Alan decided to introduce himself to the ColdFusion community as well as address some of the controversy, prompting a response from Rey Bango (again with involved discussions in the comments). The soap opera will no doubt continue and I’m hesitant to devote any more column space to it, but I think the committee itself is a step in the right direction to ensure the CFML language stays consistent amongst multiple implementations, and hopefully whatever the outcome of the drama, it will be for the benefit of the CFML community.
   
In fact, there’s already good signs that the community is serious about interoperability: Barney Boisvert reports that Railo has implemented the same underlying mechanisms for arrays and structs as Adobe ColdFusion and Open BlueDragon.
On the flip side, David Shuck questions why Adobe’s marketing department seems to be out of the ColdFusion loop, omitting it from marketing materials related to Flex where it really should be pushed (hat tip and sincere thanks to Mike Henke). From Adobe, Ben Forta (king of evangelists), Kristen Schofield (ColdFusion product manager) and Rachel Luxemburg (community manager) all responded in the comments.
Right, with that out the way, let’s get onto some information that’s actually useful!
Code
Feel like digging around in the internals of ColdFusion server? Inspired by Elliott Sprehn’s presentation at CFUnited (more on that conference is coming in a separate post), Dan Vega has been doing just that – check out what he found out about the implementation of structures, how to find the number of dimensions in an array, random number generation and how to dump all scopes.
ColdFusion Jedi Master Raymond Camden regularly posts answers to questions that readers ask him in his “Ask a Jedi” series. This week, he responds to a question about using ColdFusion Ajax with CFCALENDAR, as well as a question about a complex security scenario, a frequently asked question about browser support for ColdFusion Ajax components and gives a URL rewriting example. He also posts on clearing individual files/folders from ColdFusion’s template cache. Phew – Ray, you’re a blogging machine!
Also on code, briefly:
Steve “Cutter” Blades discusses how to build applications that scale in a very interesting case study format
Brian Ghidinelli shows us how to build reusable form views with Model-Glue
Ben Nadel warns us to be careful when using # in DE() expressions
Mark Kruger talks about writing portable ColdFusion code – for Windows and Linux/Mac servers
Oscar Arevalo tries out HomePortals and ColdBox together with interesting results
Madfella Justin Carter has released a preview of ColdExt Beta 2, the ExtJS library for ColdFusion
Nick Tong has updated his Fusebox lexicon for Transfer ORM
Charlie Griefer has written an article for Pakt Publishing on lesser-known features in ColdFusion 8 (hat tip to Ben Forta). Pakt will be releasing John Farrar’s new book on ColdFusion this month – good to see another niche tech publisher supporting the ColdFusion community. If you didn’t see it before, read an interview with John Farrar about his COOP framework here on SitePoint.
Open Source
Brian Rinalidi is out there combing through RIAForge and other sources so we don’t have to – this week, his Open Source Update reports five new projects – including a Twitter client and a new event-driven model framework by Sean Corfield – and four updates as well as some announcements concerning frameworks and a ton of tutorials, presentations and reviews. Thanks Brian, and keep up the good work!
The FarCry Framework/CMS has a new web site – looking good, guys! If you didn’t see it the first time around, read an interview with Geoff Bowers about FarCry on SitePoint – hey, you didn’t mention then that a new site was in the works, Geoff…
ColdFusion 9 Discussion
After the CFUnited “sneak peak” of what the Adobe team are working on for ColdFusion 9, there’s been some discussion of one of the proposed new features: hibernate integration. Mark Mandel, author of the popular Transfer ORM framework (read 10 questions with Mark about his product here) has written a pre-emptive post addressing concerns that CF9+Hibernate signals the end of Transfer. After thinking on the topic, Todd Sharp suggests that a CFVALIDATE tag could be a useful enhancement to Hibernate integration.
Community
The new CFConversations podcast is flying along – already, Brian Meloche has posted episodes 2, 3 and now 4, recorded on day 3 of CFUnited. The main issue discussed is how to promote CFML outside of the ColdFusion community – and Brian has also posted the results of his CFUnited ‘Community session’ on this topic. Some good ideas there!
Related to last week’s outcry about code commenting practices, Sam Larbi posts about Common Excuses Used To Comment Code and What To Do About Them.
Thanks for reading and keep coding CFML – it makes your hair curly! If you have a tip for me, email kay at smoljak dot com, leave a comment or tag the link in del.icio.us with for:kay.smoljak.
  
  



The Week in ColdFusion: 11–17 June: ColdFusion 9 sneak peak leaks
Kay Smoljak — Thu, 19 Jun 2008 15:34:50 +0000
Scotch on the Rocks and WebDU were last week (see my WebDU Day 1 post here) and CFUnited is now underway. It looks like CFUnited will generate heaps of blog posts, so I’ll probably have a separate conference round up after it’s over – but for now, a few advance details for ColdFusion 9 (coming sometime in 2009) were slipped out in the keynote address. Among these:
Hibernate ORM will be “baked in”
AIR integration will allow online and offline applications
ColdFusion will be free for educational institutions
Language updates will include a LOCAL variables scope
a CFML Advisory Committee headed up by Sean Corfield will guide the development of the language
I’ve said it before, and so have many others – it’s an exciting time to be a ColdFusion developer. I don’t think there’s been a period of growth and change like we’ve seen in the last six months in the entire 11 year history of the platform.
Back our regularly scheduled program!
   
Community 
First some sad news – the ColdFusion Weekly podcast has called it a day. Co-host Peter J. Farrell explains that the team simply didn’t have time to devote to the show. The archives will remain available, so if you don’t have them all, collect the set! Josh Curtiss points to some of his favourite episodes.
Then some good news – a new podcast called CFConversations has been started by Brian Meloche. At the moment there are two roundtable episodes: the first a discussion of conference news, jobs, CF9 rumours, and open source, amongst other topics; and the second a summary of Day 1 at CFUnited. I’ve only listened to the first one so far, but it was worth the time invested and I’ll definitely be checking out future episodes.
With the Railo announcement, there has been a lot of discussion about the future of ColdFusion. Peter Bell has written a series of four articles (plus a couple of bonuses) on where he thinks the language might be heading.
Part 1 – The Changing Landscape
Part 2 – Adobe
Part 3 – Railo’s Release
Part 4 – Whither ColdFusion
What about BlueDragon?
Adobe’s CFUnited Keynote
Sammy Larbi posts an interesting philosophical piece on why Making Mistakes Is Fundamental To Understanding.
Code
There have been lots of juicy code posts this week:
Mark Kruger discusses issues with scoping of variables in CFCs when using tags, such as CFHTTP, that create their own scope.
Steve Bryant talks about Components and CFTHREAD
Raymond Camden answers a question from a reader having a problem with using onMissingMethod inside a CFC
Ben Nadel presents his partial entry to Steve Levithan’s regular expression contest and posts about some of the intricacies of CFCATCH
Brian Kotek answers reader questions on Handling Custom Object Behavior and How to Handle Object Composition
Peter J Farrell points out that CreateUUID is slow, and tells us to use a Hash instead
Anuj Gakhar posts his thoughts about giving Transfer a try
Kevan Stannard posts about Nested Set Trees in ColdFusion
SitePoint have published a tutorial on ColdFusion Components by Ben Davies
Finally, a copy of the latest Fusion Authority Quarterly Update landed on my desk this week. Subtitled “Do More – Code Less!” this issue is dedicated to best practises and development environment tips. I’m only partway through but there’s a series of three articles on setting up and using Subversion that look very, very good.
I’m still recovering from WebDU – a wrap of the second day will be coming soon, as well as a summary of the very interesting final “speaker panel” session – interesting particularly because almost all of the questions asked were about ColdFusion, which only made up one quarter of the conference program.
Got a tip for me? Leave a comment, tag for:kay.smoljak in del.icio.us or send an email or carrier pigeon to kay at smoljak dot com. Otherwise, I’ll see you all next week – same time (approximately), but definitely same location!