RSS MAD

ColdFusion Open-Source Update - October 13, 2008

One (sorta) new project this week and one update. Obviously this is a light week for ColdFusion open source, nonetheless Russ Johnson's Skweegee (which existed previously under a different name with a different codebase but a similar concept) should be an interesting project to watch.

New Releases and Updates

New Project: Skweegee
First Public Release Of Skweegee!! Took Long Enough!
Russ Johnson released the first public version of his project management tool that aims to have similar functionality to Trac, only built with ColdFusion.

OnTap Framework
Plugin Manager Update
Isaac Dealey has updated how the framework manages plugins and all the plugins to match this change.

Mail Bag : Framework Community Picking Up Steam
Isaac Dealey responds to OnTap/DataFaucet questions from John Whish and Gabe Roffman.

Announcements

CF Gallery Creator
CF Gallery Creator / jQuery Slider Gallery
Micheal Evangelista posts about a photo gallery application he hopes to release as open source and for which he is currently seeking testers.

CFGroovy
CFGroovy Demo App Update at BarneyBlog
Barney Boisvert updates his demo application to fix an issue with MSSQL.

ColdBox
New IRC Channel - #ColdBox
You can now find ColdBox help/community on IRC.

First ColdBox Training Seminar Completed and more...
Luis Majano discusses the first ColdBox training course and plans for future courses.

Mango Blog
New Themes for Mango Blogs
Adam Tuttle highlights a new site by Mark Aplet that offers free and premium Mango Blog themes.

Transfer
Transfer Survey, now open!
Mark Mandel has put together a new survey to help determine the direction of Transfer.

ValidateThis!
ValidateThis! - An Object Oriented Approach to Validations
Bob Silverberg plans on releasing a framework for validation as an open-source project. In this post he discusses some of the underlying concepts and ideas.

ValidateThis! - Object Oriented Validations Demo Now Online
Bob Silverberg releases a demo of his validation framework that he intends to release as open-source.

Tutorials, Presentations and Reviews

ColdBox
Creating our Domain Objects - ColdBox Series Part 6
Jason Dean continues his tutorial series.

Convention over Configuration - ColdBox Series Part 5
Jason Dean continues his tutorial series.

Understanding the coldbox.xml config file - ColdBox Series Part 4
Jason Dean continues his tutorial series.

ColdSpring
A Complex Gotcha with ColdSpring, Remote Proxies and Getter/Setter Mischief
Shawn Holmes details a complex issue pertaining to generic remote proxy methods generated by ColdSpring and the metadata needed to properly work with Axis for creating/consuming web services.

FarCry
Dynamic Programming and Metadata
Jeff Chastain discusses FarCry's use of dynamic programming using metadata in CFCs.

Cairngorm Crystallized

This is a reprint with permission of an article that was originally published in the Fusion Authority Quarterly Update Volume 2 Issue 3 in October 2007 (click here to subscribe). If you would like to download the source you can find it here. I have another Cairngorm sample appliction which you can get via Subversion at http://code.google.com/p/remotesynthesis/ where you will also find the same example built with the Mate Framework. If you are interested in the Mate Framework, you can find my article on that topic in Flex Authority Volume 1 Issue 1, which you can subscribe to here.

Examining the Cairngorm Microarchitecture from a Workflow Perspective

by Brian Rinaldi and Michael Corbridge

What is Cairngorm?
Cairngorm is a framework for rich Internet application (RIA) development. More specifically, Cairngorm is a package of Actionscript 3.0 classes that help implement a number of proven design patterns to create a generic starting point for your Flex application architecture. By adapting a number of proven J2EE solutions for the RIA world, Cairngorm helps you deal with the complexity of managing state and encapsulating your business logic into reusable components while taking into account the asynchronous nature of service requests within a Flex application.

By providing this consistent architecture and proven design patterns, using Cairngorm can offer a number of benefits to your Flex application, including:

1. A centralized model (i.e. the Model Locator), which helps to decouple code and improve reusability
2. A centralized event/response system, which helps to do this as well
3. The separation of concerns along the lines of the Model-View-Controller pattern, which helps to isolate business logic and simplify maintenance
   
4. A straightforward and documented structure for application building within a team environment

By focusing on the Cairngorm workflow, this article is intended to illustrate the "how" of Cairngorm as opposed to focusing heavily on the "why." Building an application with Cairngorm tends to follow a repetitive sequence of steps that, once they are clear, make Flex development a fairly simple and organized process. The intent of this article is to walk you through these steps.

Sidebar: Who Created Cairngorm?

Cairngorm was created by Steven Webster and Alistair McLeod when both were principals of iteration::two, a company that is now part of Adobe Consulting. The ideas for the Cairngorm framework first appeared in their book Reality J2EE - Architecting for Flash MX, released by Macromedia Press in 2002.  In their book, Developing Rich Clients with Macromedia Flex, a more mature version of Cairngorm was described to specifically address the challenges of developing enterprise-level Flex applications. Cairngorm evolved as a means of organizing the callbacks associated with the asynchronous nature of remote method invocation (RMI), and making the service calls responsible for RMI centrally available within the application.

Setting Up Cairngorm

You can find Cairngorm at Adobe labs (http://labs.adobe.com/wiki/index.php/Cairngorm). Scroll down to the Downloads section and pull the zip for Cairngorm 2.2, which is the most recent version as of this writing.

Place the Cairngorm.swc file found in the bin folder of the downloaded cairngorm2_2.zip anywhere on your computer. I chose to place mine in my inetpub directory.  An ActionScript .swc file is analogous to a Java .jar file; by deploying the .swc file, the developers are stating that these are core classes that cannot be modified. Once you have created your Flex project in Flex Builder, right click on the project, select "Properties > Flex Build Path" and choose the "Library Path" tab. Next click on the "Add SWC" button, locate your Cairngorm.swc and click ok.

Basic Cairngorm Terms and Concepts
The interactions within a Flex application based on Cairngorm can be broken down into four fundamental classes:

1. Control (FrontController): This class maintains a registry of all possible service calls within the application. Any request for data or operations within the application must first go through the FrontController, which detects an event and determines which Command class to run. If you are familiar with ColdFusion frameworks such as Mach ii, Model-Glue or Fusebox, the concept of the front controller remains the same - it basically determines where to route the request.

2. Command: The Command class is called by the FrontController to execute the service call via a third class called the Delegate, returning the data to a result() function, if successful, or a fault() function, in the event of an error. 

3. Delegate: The Delegate class encapsulates access to a business service. It is an ActionScript implementation of a common J2EE pattern where the details of the business service, such as lookup and access to the ColdFusion middle tier, are contained. By abstracting these service calls in a Delegate, it is simple to point the application at an alternate source, such as a Java service, if necessary.

4. Model: The state of the application and its variables is maintained by this singleton class, usually given the filename 'ModelLocator'.  Using the 'getInstanceof' method, the model can be imported into any class, or mxml template, within the application.  ModelLocator uses Flex's data binding so that any component in the application that is bound to the model is immediately updated when a variable within the model is updated by an event result in the command class.

The Task At Hand
Our sample application is designed to pull a list of ColdFusion's built-in functions and then, once one is selected, return the LiveDocs documentation for that item, much like cfQuickDocs.com does. It has two beans or value objects: [Footnote 1: A value object is the Flex equivalent of a bean.] a "cffunction" object that represents a ColdFusion built-in function and a LiveDoc object that represents a content page from the LiveDocs site. A service component handles all of our business logic and a remoting facade component communicates with Flex via ColdFusion's built-in Flash Remoting.

Since this article is focused on Cairngorm and its workflow, we won't go into detail about the ColdFusion code. You can download all of the code for this application from http://www.fusionauthority.com/quarterly/volume2issue2. However, there are a few things to remember when building the ColdFusion back-end to your Flex/Cairngorm application:

Creating Components (CFCs) for Use with Flex and Cairngorm
The first thing you need to understand when working with Cairngorm is that, while you could technically use it without proper object-oriented service and model layers, it isn't recommended.  (For an understanding of OO concepts and the creation of separate service and model layers in your application, see Fusion Authority Quarterly Update Volume 1 Issue 2, particularly Chris Scott's article on ColdSpring.) Flex and Cairngorm expect you to deal in objects or arrays of objects, and in our experience you will find things work much more smoothly this way. For example, when you return an array of component instances, Flex will automatically translate it into an array of value objects, which can easily be used to populate a Flex array collection.

Organization
This is more a recommendation than a requirement. However, you will want to keep a nice, clean separation of your ColdFusion code from your Flex code. Cairngorm tends to generate a lot of components and classes within your application, and a disorganized components directory that is a mix of ColdFusion and Flex code could become unwieldy. Typically, we recommend putting all your Flex and ColdFusion components within a /com directory under the root, with all ColdFusion components under the /com/cf subdirectory. In a larger application, the /cf directory should be further subdivided based upon the object model of the application.

Instantiation
In order to get the data type translation between ColdFusion and Flex functioning, be sure to always use the full dot notation path to a component when instantiating it. If you are like us, you may prefer to use relative dot notation paths whenever possible to make your code a little more portable. However, this will not work if your component is intended to be automatically converted to a value object on the Flex side. So, following the organization discussed above, you could technically instantiate a docsPage object within the docsService component by doing createObject("component","docsPage"), since both the service and the bean CFCs lie in the root of /com/cf/ directory. Nonetheless, you must use createObject("component","com.cf.docsPage") for this component to be automatically translated into a DocsPage value object in Flex. We will look at how you create this value object later.

MetaData
The Flex/ColdFusion adapter will automatically translate property values as well as types when your component instance is translated into a value object. However, it requires that you include the cfproperty metadata tags in your component. For example, our ColdFusion function object (/com/cf/cffunction.cfc) has two properties:

 Listing 1: Properties of cffunction.cfc

<cfproperty name="functionName" type="string" default="">
<cfproperty name="docsURL" type="string" default="">

If you remember these important items, the ColdFusion/Flex data mapping should work perfectly every time.

Building Our Sample Application

As discussed briefly above, the goal of our application is very simple. First, we will populate a drop-down combobox with a list of ColdFusion's built-in functions and, when one is selected, we will fill a text area with the content of that function's documentation from the ColdFusion LiveDocs site.

Figure 1: A View of Our Finished Sample Application

In this section, we will focus on the workflow of getting that done in Cairngorm. While each person might individualize this process, what follows is a typical sequence, though as you become more comfortable with the process you can adjust it to your needs. As we walk you through these steps, you can refer to Figure 3 at the end of this article, so that you know exactly what we're doing and where it fits into the Cairngorm microarchitecture.

Step 1 - Function
Cairngorm has a built-in event dispatcher, CairngormEventDispatcher, that allows you to centralize and reuse code throughout your application rather than repeat business logic within each function call. For example, on initialization, our application requires a list of the available ColdFusion functions. Thus, in our mx:Application tag, we have included creationComplete="initApp()", which means that the function initApp() will be called when the application has finished loading. Our initApp() function creates a variable called cffunctionEvent which is of type GetCfFunctionsEvent.

This event takes no parameters, so we simply pass it off, as is, to our event dispatcher:

Listing 2: the event dispatcher

CairngormEventDispatcher.getInstance().dispatchEvent(cffunctionEvent)

Effectively what this line of code is doing is announcing an event to whatever part of the application may be listening for it. However, right now nothing is listening for it; in fact, the event we announced (cffunctionEvent) doesn't even exist yet, so let's create one.

Step 2 - Event
This event object uses a standard "template" of sorts for Cairngorm events and, in this case, has no properties, since our ColdFusion component method to get the list of available ColdFusion functions takes no arguments.

Listing 3: com.control

package com.control
{
    import com.adobe.cairngorm.control.CairngormEvent;
   
    public class GetCfFunctionsEvent extends CairngormEvent
    {
        public function GetCfFunctionsEvent()
        {
            super(DocsControl.EVENT_GET_CFFUNCTIONS);
        }
    }   
}

The event we are dispatching extends CairngormEvent, which in turn extends the Flash 'Event' class.  The Event constructor takes as an argument a string that describes the event to be dispatched.  This string is stored in the control class 'DocsControl' as the string: DocsControl.EVENT_GET_CFFUNCTIONS.

Step 3 - Controller
EVENT_GET_CFFUNCTIONS is simply a static variable within the Controller which further binds our event to its appropriate "handler" or command. First, we must create this variable by placing the following line before our constructor method:

Listing 4: EVENT_GET_CFFUNCCTIONS

public static const EVENT_GET_CFFUNCTIONS : String = "EVENT_GET_CFFUNCTIONS";

Next we "link" that to the appropriate command within the constructor with:

addCommand(DocsControl.EVENT_GET_CFFUNCTIONS, GetCfFunctionsCommand);

The 'addCommand' method serves two purposes. First, it ensures that the command is unique. Remember that the Cairngorm framework is designed for an enterprise development environment where a number of developers are working on the same code base. If a developer attempts to re-register the event, addCommand will throw an error indicating that the command is already registered. If it passes this test, the Flash 'addEventListener' method registers this event through the CairngormEventDispatcher singleton. Thus the cffunctionEvent you announced earlier is now bound to the appropriate command class.

Step 4 - Command
The Command class is where the guts of our application will live, and it will always have three functions: execute; result; and fault. The execute function will handle any business logic or other general application logic that needs to happen prior to our remote method call (i.e. the ColdFusion component method call). The result function will do the same with the data returned by the remote method call. The result will also usually "attach" this data to the ModelLocator which, as discussed above, allows different parts of your application to bind to data without necessarily knowing where it comes from.

Finally, the fault method is simply our error handler should anything go wrong with the remote method call.

Listing 5: The execute function 

public function execute( cgEvent:CairngormEvent ) : void {
    var delegate : DocsServicesDelegate = new DocsServicesDelegate( this ); 
    delegate.getCfFunctions();
}
       

public function result( rpcEvent : Object ) : void {
       model.cffunctions.source = rpcEvent.result as Array;
}

public function fault( rpcEvent : Object ) : void {
    mx.controls.Alert.show("Fault occured in GetCfFunctionsCommand.");
    mx.controls.Alert.show(rpcEvent.fault.faultCode);
    mx.controls.Alert.show(rpcEvent.fault.faultString);
}

The code above brings together a number of the concepts we have discussed. First, the execute method calls the appropriate method call within the delegate class, whose job it is to abstract the actual remote service call. Next, the result method binds the data returned by the remote call to the model, whereby all the relevant data bindings are automatically refreshed. Finally, the fault method simply states where the error occurred and outputs the details of that error in alert boxes.

Step 6 - Delegate

The Delegate's job is to store remote services and make the appropriate asynchronous calls. For instance, our DocsServicesDelegate (see Listing 5 line 2) holds the docsServices RemoteObject which, as we will discuss next, contains the remote call details for our docsRemote ColdFusion component methods. The line in the constructor that defines this relationship is:

this.service = ServiceLocator.getInstance().getRemoteObject( 'docsServices' );

Our delegate's methods match the remote method calls and therefore we have the getCfFunctions method, which makes the asynchronous call to getCfFunctions within our ColdFusion component. Remember, getCfFunctions doesn't take any arguments; later we will look at an example where we need to pass data to ColdFusion.

Listing 6: getCfFunctions

public function getCfFunctions() : void {
    // call the service
    var token:AsyncToken = service.getCfFunctions.send();
    // notify this command when the service call completes
    token.addResponder( command );
}

It is important to point out here that the Delegate within our sample application deviates slightly from the standard practice, as it wraps up multiple method calls. This is a little bit of economizing and improvising on our part and suits a small application. However, when building a large application you may want to consider breaking your Delegates apart so that each one represents a single method call.

Step 7 - Service

Our service (Services.mxml) contains the necessary remote object calls to connect Flex and ColdFusion. In this case, we will have one RemoteObject with two methods:

Listing 7: RemoteObject

<mx:RemoteObject
    id="docsServices"
    destination="ColdFusion"
    source="cairngormcf.com.cf.docsRemote">
    <mx:method name="getCfFunctions" />
    <mx:method name="getFunctionDoc" />
</mx:RemoteObject>

Step 8 - Value Object
If you have taken a look at the ColdFusion code, you will notice that the getCfFunctions() method returns an array of cffunction.cfc instances.

<cffunction name="getCfFunctions" access="public" output="false" returntype="array">
    <cfset var i = 0 />
    <cfset var functionList = getFunctionList() />
    <cfset var cfFunctionListArray = arrayNew(1) />
    <cfset var functionName = "" />
    <cfset var thisURL = "" />
    <cfset var sortedFunctions = listToArray(structKeyList(functionList)) />
    <cfset arraySort(sortedFunctions,"text")>

    <cfloop from="1" to="#arrayLen(sortedFunctions)#" index="i">
        <!--- get the docs url --->
        <cfset thisURL = getFunctionURL(sortedFunctions[i]) />
        <cfif len(thisURL)>
            <!--- must use fully qualified dot notation path --->
            <cfset arrayAppend(cfFunctionListArray,createObject("component","cairngormcf.com.cf.cffunction").init(sortedFunctions[i],thisURL)) />
        </cfif>
    </cfloop>
    <cfreturn cfFunctionListArray />     
</cffunction>

The cffunction.cfc is a simple bean - though it does not have to be. It does, however, contain the cfproperty tags representing its object properties. If you have the ColdFusion extensions for Flex Builder installed, the next step is quite easy. Right-click on the cffunction.cfc and go to "ColdFusion Wizards > Create AS class (based on CFC)". This wizard will create a Flex value object based upon the ColdFusion component metadata. Simply supply the location (/com/vo/), the class name (cffunctionVO.as) and the full dot notation path to the ColdFusion component it represents (cairngormcf.com.cf.cffunction). Now whenever an instance of cffunction.cfc is passed to Flex, it will be automatically converted to an instance of cffunctionVO.as within Flex.

Rinse and Repeat
At first glance, this may seem like quite a lot of code to manage, but once you get into the workflow of Cairngorm you start to realize that 1) all these pieces are necessary; and 2) this isn't nearly as difficult or time consuming as it seems. We've now added the functionality that fills our drop down ComboBox when the application first loads. As a review, let's quickly cover how we would add the functionality whereby when you choose a ColdFusion function name from the combobox, it grabs the appropriate documentation from the LiveDocs.

Our FunctionSelectPanel view component contains the ComboBox display code. We first add a change event to the ComboBox that calls getDocs() when an item is selected.

Since the ComboBox was populated with an ArrayCollection of cffunctionVO value object instances, the selectedItem will be an instance of cffunctionVO. Just as cffunction.cfc was automatically converted to cffunctionVO.as, the reverse is also true and our cffunctionVO instance will become a cffunction.cfc instance when passed to ColdFusion.

Therefore, our getFunctionDoc method in our docsRemote component takes an instance of cffunction.cfc and our GetFunctionDocEvent will take an instance of cffunctionVO as follows:

Listing 8:

private function getDocs() :void {
    var cffunction : cffunctionVO = functionSelect.selectedItem as cffunctionVO;
    var event : GetFunctionDocEvent = new GetFunctionDocEvent(cffunction);
    CairngormEventDispatcher.getInstance().dispatchEvent( event );
}

Since the GetFunctionDocEvent takes an argument, the event template needs to account for this argument as a property of the event object, as shown below in Listing 9 (line 10). However the controller code still follows the same pattern discussed above:

Listing 9: com.control

package com.control
{
    import com.adobe.cairngorm.control.CairngormEvent;
    import com.vo.cffunctionVO;
   
    public class GetFunctionDocEvent extends CairngormEvent
    {
        public var cffunction : cffunctionVO;
       
        public function GetFunctionDocEvent(cffunction:cffunctionVO)
        {
            super(DocsControl.EVENT_GET_FUNCTIONDOC);
            this.cffunction = cffunction;
        }
    }   
}

The execute method of our command also accounts for this argument by creating an instance of our event and passing the value on to the Delegate:

Listing 10: execute

public function execute( cgEvent:CairngormEvent ) : void {
    var delegate : DocsServicesDelegate = new DocsServicesDelegate( this );
    var getFunctionDocEvent : GetFunctionDocEvent = GetFunctionDocEvent( cgEvent ); 
    delegate.getFunctionDoc(getFunctionDocEvent.cffunction);
}

The matching Delegate method simply takes the data and passes it along to the remote object call:

Listing 11:

public function getFunctionDoc(cffunction:cffunctionVO) : void {
    var token:AsyncToken = service.getFunctionDoc.send(cffunction);
    token.addResponder( command );
}

Since getFunctionDoc returns an instance of the docsPage.cfc, we also need to create the docsPageVO.as, using the ColdFusion wizard in the same manner outlined above.

Conclusion
I hope that the above has illustrated how Cairngorm can help establish an organized workflow with Flex to send, receive and respond to data with ColdFusion. While it can seem overwhelming at first, once you have established the workflow I believe you will find developing with Cairngorm to be very straightforward. In addition, once you have developed your first application I think the benefits discussed at the beginning of this article will become very clear.

If you would like to learn more about Cairngorm, I recommend the following resources:

• Steven Webster's six part series on Cairngorm at the Flex Developer Center - http://www.adobe.com/devnet/flex/architecture.html
• The Cairngorm documentation and tutorial site at http://www.cairngormdocs.org/
• Joe Rinehart's series focusing on Cairngorm for ColdFusion developers (with a tilt towards Model-Glue) - http://www.firemoss.com/blog/index.cfm/Cairngorm
• Alex Uhlmann provides detailed and up-to-date information in his blog: http://weblogs.macromedia.com/auhlmann/

ColdFusion Open-Source Update - October 6, 2008

Three new projects and three updates this week. The question I have this afternoon, unrelated to ColdFusion and open source, is, do we get to celebrate DOW 10,000 all over again when this eventually comes back around? As a follow up, how stupid do James Glassman and Kevin Hassett, authors of the now infamous DOW 36,000, seem in retrospect? They probably haven't skipped a beat and are rushing out a book called "DOW 1,000" to cash in on the recent decline. Anyway, back to the topic at hand...

New Releases and Updates

New Project: ColdDoc
Initial Release
Mark Mandel makes a port of JavaDoc for ColdFusion to generate API documentation. Code currently only in Subversion.

New Project: ColdFusion Facebook Application
ColdFusion and Facebook
Gavin Vincent has created this starter application for writing Facebook applications in ColdFusion.

New Project: Unfuddlecfc
Unfuddlecfc
Terry Ryan created this CFC that implements the Unfuddle API in order to automate getting backups.

cfUniForm
cfUniForm v2.5 - New jQuery Plugin Integration
Matt Quackenbush released a new version of his forms custom tag set that includes new jQuery plugin integration.

ColdFusion on Wheels
Wheels 0.8.2 Released
Chris Peters posts about this bug fix release.

Soundings
Soundings 2.1
Ray Camden announces a mostly a bug fix release but also includes some UI improvements and the removal of cflogin due to certain bugs.

Announcements

ColdBox
New ColdBox Flickr Group, Upload your media!
Upload photos, video or screenshots to the ColdBox Flickr group.

Mango Blog
Share This! A Social Bookmarking Tag For Mango Blog
Mark Aplet created this plugin for Mango Blog.

MXUnit
Ajax Testing with MXUnit, Webdriver, and Firefox
Bill Shelton posts about a new project called CFWebdriver Experimental that will allow for UI testing.

Razuna
Razuna 1.1.2 meets Gears
The new version of Razuna will use Google Gears to speed up the performance of highly used files.

Tutorials, Presentations and Reviews

ColdBox
A Look at Event Handlers - ColdBox Series Part 3
Jason Dean covers what event handlers are and how to define them in his ongoing series.

ColdSpring
Using ColdSpring Interceptors With Remoting Proxies
Scott Stroz shows how to use ColdSpring AOP to format data for a cfgrid or other Ajax calls.

ColdFusion to Flex Object Type Conversion via ColdSpring
Steve Brownlee discusses using ColdSpring AOP to convert queries to arrays of objects.

Fusebox
Fusebox 5 Pet Peeve of the Day
Shawn Holmes starts what sounds like it will be a series with a complaint about "no fall-through support for 'No-XML' Implicit Circuit Detection."

General (Frameworks)
An introduction to ColdFusion frameworks - now on Adobe Devnet!
Mark Mandel writes an article that covers the various types of ColdFusion frameworks and some examples of each in this comprehensive article.

Mango Blog
Ask a Grokker: Why can't I activate an inactive Plugin in Mango?
Adam Tuttle shows how to activate a plugin that is refusing to activate via the admin UI.

OnTap Framework
IoC Manager, Lazy Loading and SOA
Isaac Dealey dicusses the IoC Manager in OnTap and how that can help to build service oriented architectures.

Reactor
Gotcha with Reactor records and exists()
Tom Chiverton discusses an issue with checking if a record exists and how to work around it.

Flex Camp Boston 2008 Is On!

I have been working behind the scenes for the past month or two to secure the support necessary to host another Flex Camp Boston this year. Thanks to the generous support of both Adobe and my employer, Universal Mind, I can now definitively say that Flex Camp Boston 2008 is a go. We don't have a ton of information yet, as we work on cost, speakers and sessions, but be sure to save the date, December 12, 2008 at Bentley College in Waltham from 8 to 5pm!

Last year's event, also at Bentley, was a huge success bringing in nearly 300 developers from around the New England area and, to my own surprise, around the country to hear some of the top Flex and AIR developers from both inside and outside Adobe speak. At the time, this was by far the largest Flex Camp event yet (and for all I know it may still be). I am working on not just matching the success of last year, but hoping to exceed it, so I think this will be an event you simply don't want to miss as a Flex or AIR developer. I haven't updated the Flex Camp Boston site for this year's information yet, but look for that soon, and be sure to watch that and/or this site for more details soon.

ColdFusion Open-Source Update - September 29, 2008

One new release and five updates this week as well as a lot of announcements. I made sure to release this update tonight to help calm the markets tomorrow. Your banks may be failing and credit may be disappearing but lest anyone think that the world of ColdFusion open-source is anything but healthy.

New Releases and Updates

New Project: VICO CRM
Initial Release
This project by Marius Milosav is a multilingual customer relationship management suite of applications.

CFWheels
Wheels 0.8.2 Released
This release fixes a number critical bugs.

Lighthouse Pro
Lighthouse Pro 2.5 (Beta)
Lighthouse Pro gets a new design, milestones and reworked Ajax functionality using JQuery.

Mach-II
Mach-II 1.6.0 Beta Released
Peter Farrell announces that Mach-II 1.6 is now in official beta. This release includes things like a new caching package, new logging package and a new publish/subscribe listener method invocation.

MXUnit
MXUnit 1.0.3 Now Available
Marc Esher announces that this release is mostly a bug fix release but also allows the DirectoryTestSuite to work with relative paths.

POI Utility
"Style Bleed" Problem Fixed In POI Utility Tags
Ben Nadel fixes an issue in his POI Utility thanks to a tip from Nathan Mische.

Announcements

ColdSpring
FacadeStarter Updated
Tom Chiverton updates his FacadeStarter for ColdSpring.

Lighthouse Pro
More on the Ajax changes to Lighthouse Pro
Raymond Camden goes into more detail on the reasoning and decisions behind the recent changes to Lighthouse Pro.

Mach-II
Config File Reference is Ready for Action
Brian FitzGerald announces a config file reference document has been added to the wiki.

MachII
A Warm Team Mach-II Welcome to Brian FitzGerald
Brian FitzGerald joins Team Mach-II as the Wiki manager.

Mango Blog
Show your Mango pride
You can now add Mango badges to your Mango powered blog.

OnTap Framework
Clarifying the Galleon Forums Project
Isaac Dealey clarifies why he went through porting over Ray's Galleon forums to several frameworks, including OnTap.

POI Utility
Java Hashtable - An Object-Based-Lookup "Struct" (Thanks Nathan Mische)
Ben Nadel goes into detail about the issue Nathan Mische found in his POI Utility.

Razuna
Why Razuna is more then a open source digital asset management system
This posts discusses Razuna's full-featured CMS system and API.

Reactor
The First Reactor Meeting
The first Reactor meeting seems to have focused on organizing the requirements of future meetings and laying the groundwork for contribution.

Skweegee
Skweegee Private Beta Is Underway
Russ Johnson announces that the Skweegee private beta may allow for a 0.4 release by the end of the week, provided there are no major issues.

Squidhead
Squidhead Still Swimming
Terry Ryan announces that Nathan Mische and Dave Konopka are joining his Squidhead project.

WhosOnCFCDB
September Update
Shane Zehnder says that though development on WhosOnCFCDB has temporarily stalled, he will be returning to it soon.

Tutorials, Presentations and Reviews

BlogCFC
My BlogCFC mods for Windows Live Writer
Dan Switzer discusses some changes he made to the XML-RPC code.

ColdBox
Setting up a ColdBox Application - ColdBox Series Part 2
Jason Dean continues his series discussing installation of ColdBox and ColdSpring, the database and the directory structure among other things.

Coldspring
Coldspring stopped me cold..
Terry Palmer discusses an issue he encountered with ColdSpring and how he solved it.

ColdSpring
ColdFusion SOA back-end for Flex, AJAX using ColdSpring… Part 3
Hem shows the gateway he uses for Flex, Ajax and Webservice calls.

Model-Glue
When is coupling OK? Frameworks & Services & Applications... oh my!
Jared Rypka-Hauer responds to a mailing list question about whether using the new bean injection functionality couples your model too tightly with a particular framework.

Transfer
Transfer Query - From Phrase to AND Search
Raymond Camden shows how to do create a multi-word search query using TQL.

ColdFusion Open-Source Update - September 22, 2008

No new releases and three updates this week in the world of ColdFusion open-source...but let's get to why you are really here: yes, I noticed the lowly Dolphins beat the Patriots yesterday. I'd say this was the first sign of the apocalypse but there are a few things to consider: a) the Pats didn't have Brady or Mulroney; b) the Pats always seem to play down to the Dolphins level (see 2006); c) I promised my first-born to some fellow named Rumpelstiltskin.

New Releases and Updates

cfUniForm
cfUniForm v2.4 - Bug Fixes
Matt Quackenbush releases a bug fix release of his form custom tags.

Google Calendar, Google Contacts
Google Calendar/Contacts update
Raymond Camden updates both projects which can now support hosted accounts.

Mango Blog
Mango 1.2 released
Laura Arguello announces the new features including automatic updates, a more responsive cache and lots of minor fixes and improvements.

Announcements

ColdSpring
What's New In ColdSpring 1.2?
Brian Kotek posts some details about the new features in ColdSpring 1.2.

DataFaucet ORM
Liquify Converts Queries to DataFaucet For You
Isaac Dealey talks about some misunderstanding of his tool to convert queries to DataFaucet format.

Fusebox
Fusebox Status
Adam Haskell discusses the state of the Fusebox codebase and some changes he is working on already.

Mach-II
New Mach-II Workshops (Feedback Needed)
Kurt Wiersma posts about a survey to get feedback on dates and content for the revamped workshops.

Razuna
SixSigns and our products getting social
Razuna is now on Twitter and Facebook.

Reactor ORM
The Future of Reactor
Mark Drew discusses his new post as the lead for Reactor ORM.

The Future of Reactor
Doug Hughes defends Reactor's continued relevance and announces that he has handed the reigns over to Mark Drew. They will be hosting public planning meetings every Wednesday from 12 noon to 1pm EST time, see the post for full details.

Remember Reactor ORM?
Sami Hoda posts about the change of leadership for Reactor and two of his gripes about functionality in Reactor.

Tutorials, Presentations and Reviews

cfUniForm
I Present to the Hartford CFUG on CFUniform
Dan Wilson presented on Matt Quackenbush's CFUniform project.

ColdBox
Dynamic Component Paths in ColdBox
Tony Garcia shows how to use dot-delimited (rather than slash) dynamic paths in ColdBox.

Building an Application with ColdBox and ColdSpring - Part 1
Jason Dean posts the first in his series. This one covers creating a UML diagram for the project which will be a to-do list application.

ColdSpring
ColdFusion SOA back-end for Flex, AJAX using ColdSpring… Part 1
Hem talks about his architecture for a Flex application communicating with ColdSpring on the ColdFusion side.

ColdFusion SOA back-end for Flex, AJAX using ColdSpring… Part 2
Part 2 of Hem's series.

Fusebox
OO and Fusebox no xml
John Whish converts a sample application by Brian Kotek from Fusebox 4 to 5.5 with no XML.

POIUtility
Cell Style Caching Issue With POIUtility
Nathan Mische posts about how to correct an issue in Ben Nadel's Excel file project.

QueryParam Scanner
Loving QueryParam Scanner
Steve Bryant talks about his success using Peter Boughton's tool for client projects.

DAO's a Waste of Time?! Peter and I continue the CFArgument.

Peter Bell and I have posted the second in our ongoing CFArgument series, this time we debate whether DAOs are a waste of time. You can probably guess which angle I took. Anyway, as we will be alternating who gets the full post each week, this was Peter's turn, so catch the full post over at his blog. If you missed the last one on the Iterating Business Object, you can find it here.

On another note, if anyone has suggestions for topics you would like to see Peter and I debate, feel free to let us know.

Serialize and Deserialize a Component in ColdFusion 8

I am working on a project where a requirement for serializing and deserializing a component came up. This is possible now with ColdFusion 8, since the underlying work was done (by Rakshith) to handle synchronizing sessions across a cluster. Nonetheless, there is no specific serialize or deserialize function for a CFC. Pete Frietag wrote about this as did Rakshith in earlier posts. My code below borrows pretty liberally from theirs but distills it into two CFC methods that I include a utility component to handle the serializing and deserializing. Also, I am not writing the serialized data to a file as in their examples, but passing you back Base64 data in the one case of the serialize() method. This was done so I could store the result in a database for reasons I won't get into here. One odd thing that came up when I tested this was that putting a returntype of "component" would not work on the deserialize method even though the result looks and behaves like a component instance, thus the returntype of "any." Below is the code for the two methods (keep in mind, I have only tested this on some simple CFC instances, share if you run into any issues).

<cffunction name="serializeCFC" access="public" output="false" returntype="String">
   <cfargument name="cfc" type="component" required="true">
   
   <cfset var byteOut = CreateObject("java", "java.io.ByteArrayOutputStream") />
   <cfset var objOut = CreateObject("java", "java.io.ObjectOutputStream") />
   
   <cfset byteOut.init() />
   <cfset objOut.init(byteOut) />
   <cfset objOut.writeObject(arguments.cfc) />
   <cfset objOut.close() />
   
   <cfreturn ToBase64(byteOut.toByteArray()) />
</cffunction>

<cffunction name="deserializeCFC" access="public" output="false" returntype="any">
   <cfargument name="base64cfc" type="string" required="true" />
   
   <cfset var inputStream = CreateObject("java", "java.io.ByteArrayInputStream") />
   <cfset var objIn = CreateObject("java", "java.io.ObjectInputStream") />
   <cfset var com = "" />
   
   <cfset inputStream.init(toBinary(arguments.base64cfc)) />
   <cfset objIn.init(inputStream) />
   <cfset com = objIn.readObject() />
   <cfset objIn.close()>
   
   <cfreturn com />
</cffunction>

ColdFusion Open-Source Update - September 15, 2008

One new project and eight updates this week including the long awaited update to ColdSpring. On a more pressing topic, are the Miami Dolphins the worst football team to ever play the game, even worse than the Dolphins of last year. The Miami Herald says of this last game, "This wasn't just ugly and embarrassing. This was ugly and embarrassing by the standards set by the lowly Miami Dolphins of 2007." Based on the score, they were being kind. Oh, you came here for ColdFusion open source? Fine...

New Releases and Updates

New Project: CFEclipse Dictionary Generator
CFEclipse Dictionary Generator Released
Geoff Bowers posts about this project which generates an XML dictionary for CFEclipse based upon a directory of components and tags.

BlogCFC
Few quick notes (BlogCFC, TV, and a Textmate query)
Raymond Camden fixes a critical bug in BlogCFC.

CFImageCropper
Quick cfimagecropper update
Todd Sharp posts an update to his image cropper custom tag to fix some missing folders in the zip download on RIAForge.

cfUniForm
cfUniForm v2.3 - Optgroup Support and Other Feature Enhancements
Matt Quackenbush added optgroup support to his form tags.

ColdFire
ColdFire Update Released
Nathan Mische released an update to both the Firefox extension and the debugging template.

ColdSpring
New ColdSpring.org Site Launched
Rachel Lehman contributed the new site design for the ColdSpring Framework.

Truths and Lies: Big new from ColdSpring!!
Chris Scott announces the new version of ColdSpring and the new site.

Mach-II
Mach-II Dashboard Updated
Peter and Kurt have updated the look and feel and charts for the caching statistics.

OnTap Framework
FireLadder Scaffolding Tool Released!
Isaac Dealey released a scaffolding tool for the OnTap Framework that uses his DataFaucet ORM.

TransferSync
TransferSync v0.3 released
Tom De Manincor updates his JMS gateway that keeps Transfer's cache synchronized with some quick fixes and enhancements.

Announcements

ColdSpring
ColdSpring 1.2 Gold, and New ColdSpring Site
Brian Kotek has written a new quick start guide for ColdSpring 1.2.

cwBlog
cwBlog: Initial Thoughts
Francois Levesque posts his initial thoughts on the architecture of his new blog software.

Mach-II
CFC Primer Parts 3, 4 and 5 Published
The remaining parts to Matt Woodward's CFC primer have been posted.

What's New in Mach-II 1.6 Quickstart Available
Peter Farrell posts about a new quickstart guide.

Mango Blog
Related Entries plugin for Mango Blog
Adam Tuttle, the new king of Mango plugins, created this one that lists related entries below each post.

MangoBlog Plugin: TinyMCE Manager
Stephen Moretti wrote this plugin after getting frustrated with code display in TinyMCE.

Model-Glue
New Model Glue 3 Feature: copyToScope()
Dan Wilson posts about this new feature which makes it easier to pull variables out of the event scope and place them into another scope.

OnTap Framework
Framework Survey
Isaac Dealey wants people's opinion on frameworks, not specifically OnTap users.

Tutorials, Presentations and Reviews

CF Groovy
CF Groovy Preso at BarneyBlog
Barney Boisvert posts the recording and materials from his presentation to the PDX RIA group.

cfUniForm
For the Love of Chocolate, Style Your Optgroup!
Paul Marcotte quickly shows how to modify the default optgroup style.

ColdBox
Blogging My Experiences with ColdBox
Jason Dean starts off his series with a disclaimer and some discussion about what he intends to do with the series.

ColdFire
Experiment in Tweaking ColdFire (for MS SQL)
This post shows how to customize certain aspects of ColdFire.

ColdSpring
When to use autowiring in ColdSpring
Steve Brownlee discusses when to use autowiring rather than how to use it.

Fusebox
How to Drive Fusebox 5.5 - Book Review
Niall O'Doherty reviews Jeff Peters new Fusebox book from Proton Arts.

Model-Glue
Transfer, Model-Glue and makeEventBean()
Scott Stroz posts about using the makeEventBean method with Transfer.

MXUnit
Some Benefits of Unit Testing
Bob Silverberg talks about MXUnit, a discussion with Paul Marcotte and making inroads with TDD in a corporate culture.

Transfer
Get Objects from Transfer by Table Name
I wrote about trying to get Transfer objects by table name.

CFConversations 15, Interview 10 - Mark Mandel - 09/14/08
Dan Wilson interviews Mark Mandel.

CFArgument: The Iterating Business Object

This is the first entry in a planned series of discussion between myself and Peter Bell where we will discuss hot topics in the ColdFusion community (thus the label CFArgument). Today's topic is Peter's own iterating business object, which has been the source of some discussion lately.

Peter Bell:
An Iterating Business Object is a ColdFusion specific design pattern allowing you to write OO code without worrying about the performance overhead of creating arrays of objects in ColdFusion. In ColdFusion, if you're not using an IBO, you're not really writing OO code.

Brian Rinaldi:
An IBO is a workaround to a ColdFusion specific performance issue, and that is the high cost of object instantiation. That issue has improved in ColdFusion 8, but when dealing in large sets of objects the cost can still be a killer. That doesn't mean that the IBO isn't a reasonable workaround, but without this issue the IBO has no intrinsic value. For example, if they fix performance on object creation in ColdFusion 9, the IBO ceases to be useful.

Peter Bell:
I agree that if object instantiation was faster, the IBO wouldn't be necessary. I certainly wouldn't propose using an IBO in Java or Groovy, but what I think is pernicious is the frequent use of Gateway objects that return recordsets rather than objects. Many CF developers will return a single record as an object and a collection of records as a recordset. To me that makes no sense. If you have a User object and you want to have a getAge() that calculates the age from the date of birth, that method is equally necessary (and should therefore be equally available) whether you're looking at one user or a hundred. Same for products with a getDiscountedPrice() or other potentially complex calculations.

I would argue that the lack of consistent use of IBOs means that many developers end up with pseudo-OO code which has all of the costs of OO programming (more files, more typing) but few of the benefits (encapsulating data and associated methods into objects) because they can't encapsulate custom getter logic in their beans since they are using recordsets for displaying collections of objects instead of an IBO. They are doing this because of the fear of the cost of the object instantiation. That to me is the problem with not using an IBO.

Brian Rinaldi:
We agree that using straight query results isn't optimal in all cases. I also agree that the IBO is a reasonable response, even though it does force you to repeat yourself a bit, putting logic in both the bean and the IBO. It would seem to me there are potential solutions to this that don't require code repetition. Also, one can argue that in many cases, simple recordset data meets the requirements. Nonetheless, neither case is optimal for remoting with Flex.

Peter Bell:
The thing I love about the IBO is that you don't need to repeat yourself at all. The way I use the pattern a business object is simply a collection of n-beans where n=1. At first I thought this was a little hacky (let's be frank - the IBO *is* a little hacky - violating the single responsibility principle if nothing else, by duct taping an iterator onto your business objects), but having used it in a bunch of projects, I find that it works really well.

With an IBO, I can load up one record and treat it as a business object or n-records and use it as an iterator. Perhaps the most useful way of thinking of an IBO is as a base class that your business objects can extend to allow your custom getter, setter and validation logic to be written as if you were writing a regular business object in Java. However, instead of creating an array of such objects plus a separate iterator, with the few base methods in an IBO, you simply load up an array, recordset, struct or collection of value lists into the IBO and then get all of the benefits of an array of business objects with an iterator - with almost none of the instantiation cost.

The only cost is the slightly bitter taste at having to stick iterator logic in a base business object which I agree is hacky. But it just works so darned well!

There were two other points you made as well that I'd like to respond to briefly.
If you genuinely have recordsets with no custom getter logic, I agree that an IBO might be overkill. My problem is that my simple business objects often get more complex over time so I have found for my use case using IBOs consistently gives me the room to expand and no real extra complexity upfront. I'd much rather use IBO's for everything or nothing than have to try to decide on a business object by business object basis which one was likely to become complex over time.

As for Flex, the trick would be to have a simple routine that would loop through all of the getters of an IBO for each instance, creating a collection of named structs. That gives the strongly typed VO's in Flex without the cost of creating an array of objects. I haven't had a need to write this yet, but it'd be pretty simple to add an asFlexVOs() method to the IBO - whether it was done in the IBO or handled by a composed object.

Brian Rinaldi:
Well, I think we can both agree that the best solution to this issue would be for Adobe to remove the high cost of object instantiation. I think things like the IBO, while useful to solve a problem, continue to solidify the idea that ColdFusion isn't designed for real OO development.

Peter Bell:
I agree. And there are some problems that an IBO doesn't solve. For example, very few ColdFusion applications have a truly rich object model with things like an Address value object for handling Billing and Shipping addresses composed within an Order object because the cost of object instantiation makes it impractical. It is interesting to see that some CF developers are moving to Groovy for their model and others are looking at other implementations such as Railo where object instantiation appears to be much faster. Hopefully amongst all of the great new features in CF 9 there will be some engineering time left over to address the issue and make ColdFusion a compelling language for creating dynamically typed OO applications on the JVM.

Get Objects from Transfer by Table Name

It's nice to be back in the world of ColdFusion at work, if temporarily. I am working on an idea for a Flex project where I am toying with using both ColdSpring and Transfer. For reasons I won't get into here, I wanted to try creating a generic base DAO that could handle all my CRUD via Transfer. This DAO would handle creating the Transfer object, populating it and inserting, updating or deleting it. However, I didn't want anything calling this base DAO to know that it used Transfer, I just wanted to pass a table name and a struct of properties.

To make a long story...well...short-er, this all led to a need to find a way to get an object by simply passing the table name. As far as I can tell having examined the Transfer docs, there isn't a way to retrieve Transfer's metadata information (other than by object) or its config file location even (please correct me if I am wrong...Mark?). This led me to simply reading the config file and parsing it, creating a structure that mapped table names to object names with packages in Transfer.

Anyway, below is some sample code I came up with to do this. It's not rocket science, mostly just basic XML parsing, but it works. I am not even sure I am going to use this idea (perhaps its more trouble than its worth), but I figured I'd share nonetheless.

<cfset variables.transfer = application.factory.getBean("transfer").getTransfer() />

<cffile action="read" file="#expandPath('/config/Transfer/Transfer.xml')#" variable="transferXML" />

<cfset packages = xmlSearch(transferXML,"//package") />
<cfset tableObjectMap = structNew() />
<cfset currentPackage = "" />

<cfloop array="#packages#" index="thisPackage">
   <cfset currentPackage = thisPackage.XMLAttributes.name />
   
   <!--- loop over the objects --->
   <cfloop array="#thisPackage.xmlChildren#" index="thisObject">
      <cfset tableObjectMap[thisObject.xmlAttributes.table] = currentPackage & "." & thisObject.xmlAttributes.name />
   </cfloop>
</cfloop>

<cfset product = variables.transfer.new(tableObjectMap["products"])>
<cfdump var="#product.getClassName()#" />

In this scenario, the above code outputs "products.Product", which is the package and name of the object associated with the products table. Note, my thought at the moment would be to create this map at the same time as I instantiate ColdSpring (and thereby Transfer) and then pass it through. Like I said, I am not thrilled with my idea. Anyone have a better one?

ColdFusion Open-Source Update - September 8, 2008

Two new projects and four updates this week. A very quiet week with only a handful of posts to report on. Perhaps everyone was preparing for the opening of the NFL season. My Dolphins still stink but not as putridly (which would have been an accomplishment). Though with Tom Brady apparently out for the season, the AFC East is guaranteed to be won by team that is, at best, mediocre. Anyway, though I am sure you came to my site for its highly regarded sports commentary, I am obligated to give you some ColdFusion open-source news...

New Releases and Updates

New Project: Dom CFC
Initial Release
Lucas Moellers wrote this CFC to convert HTML to XML and manipulating nodes.

New Project: Google Contacts Wrapper
Google Contacts Wrapper
Raymond Camden wrote component that can retrieve contacts and groups from your Google account.

cfUniForm
cfUniForm v2.2 - Firefox 3 Update
Matt Quackenbush updates his project with a fix for an issue with jQuery and FF3.

CodeCop, sebtags
sebtags 1.0 RC2 for ColdFusion 8.01
Steve Bryant has corrected a ColdFusion 8.0.1 incompatibility.

MXUnit
MXUnit Eclipse Plugin Test History Feature
Marc Esher writes about a new feature of the Eclpse plugin that records the history of your test runs.

WhosOnCFC
Shane's ramblings: WhosOnCFCDB is Officially an RIAForge Project
Shane Zehdner posted the database version of his project on RIAForge.

WhosOnCFCDB 0.90b Available on RIAForge
Shane Zehnder has released an new version of his project that has a database back-end and uses Transfer.

Announcements

cwBlog
Announcing cwBlog!
Francois Levesque is writing his own blog engine.

Fusebox
Fusebox in Java??
Adam Haskell contemplates writing all or a portion of Fusebox in Java.

Fusebox 5.5 Documentation
Adam Haskell notes some additional documentation sources that people may not be aware of.

Mach-II
CFC Primer Parts 1 and 2 Published
Matt Woodward has added two CFC primers to its quickstart documentation.

Model-Glue
Announcing Model-Glue Training in October
Doug Hughes and Alagad announce another Model-Glue training in Raleigh in October.

Tutorials, Presentations and Reviews

MXUnit
Designing for testability: today's real-world example
Marc Esher offers this tutorial.

Transfer
Hibernate and Inheritance
Sean Corfield compares some features that exist in Hibernate that aren't yet available in Transfer.

ColdFusion Open-Source Update - September 2, 2008

4 new projects and 12 updates this week...or actually two weeks. I took last week off as I was away on vacation in lovely Hershey, PA, with my family. This left me with a lot to cover this week, so let's get to it.

New Releases and Updates

New Project: CFCache
Initial Release
This project by Nick Sollecito does partial page caching.

New Project: CFjqAjax
Initial Release
Michael Sprague released this project that replicates CFWindow, CFTooltip and CFGrid with alternatives built with JQuery.

New Project: ColdContract
Implementing Design by Contract in ColdFusion using Coldspring AOP
David Beale shows how to implement "Design by Contract" assertions using ColdSpring AOP.

ColdContract at RIAForge.org
David Beale launches his "design by contract" project for ColdSpring on RIAForge.

New Project: TransferSync
The 'Optimized for Coldbox' edition of TransferSync now available
Tom DeManincor updated his project to optimize it for ColdBox.

Clustered? Keep Transfer's Cache in Sync with ActiveMQ JMS
Tom DeManincor posts a new project for managing the Transfer cache in a clustered environment.

cfExcelProxy
cfExcelProxy - Returning Available Styles
Francois Levesque added a way to get all the styles available to a workbook.

cfExcelProxy - More Methods Added
Francois Levesque has added setCellsFromQuery, getQueryFromCells, getCellRangeValueAsArray, mergeCells and shiftRow.

CFWheels
Released: ColdFusion on Wheels Version 0.8
Some of the new features in this release include Oracle support and composite key support, along with a number of bug fixes and improvements.

Upgrade to Wheels 0.8.1
The is a bug fix update to the recent 0.8 release.

ColdBox
ColdBox Eclipse Reference Plugins Updated
This updates the reference to match version 2.6.1.

GoogleCal, ScopeCache
Minor Updates
Raymond Camden has updated his GoogleCal and ScopeCache projects.

Mach-II
Mach-II Dashboard Module - Development Helper Application
Peter Farrell announces an alpha release of a brand new Mach-II dashboard application.

MXUnit
MXUnit 1.0.2 Now Available
Marc Esher announces that this version includes new functionality for mocking objects for a test.

Nested Set Trees
Nested Set Trees in ColdFusion (v0.8)
Kevan Stannard updates his project for managing a nested set model of trees.

qpScanner
QueryParam Scanner - Eclipse Plugin
Peter Boughton offers a pre-release version of an Eclipse plugin that works with version 0.7 or higher of his qpScanner project.

Razuna
Razuna 1.1.1 now available
SixSigns announces a bug fix release of its digital asset management/CMS system.

RIAforge
RIAForge Updates
Raymond Camden has enabled a project to have multiple admins, though right now they can only edit low level information about a project.

Transfer
Transfer 1.1 Release Candidate 2
Mark Mandel posted the latest release candidate of his ORM project which contains a bunch of bug fixes and new features.

Announcements

Bytespring CMS
Sites using Bytespring CMS
Jason Sheedy found some new sites using his content management system.

cfExcelProxy
cfExcelProxy - Wiki Launched
Francois Levesque launched a wiki with some documentation for his POI wrapper.

cfExcelProxy - Optimizing A Query Dump
Francois Levesque talks about how he optimized the performance on his POI wrapper.

cfExcelProxy - What Features Are Missing For A Complete Release?
Francois Levesque asks users what other features they need.

ColdBox
The ColdBox SideBar, a developer's companion
Luis Majano talks more about some of the framework related shortcuts and tools available on the toolbar.

ColdBox is Twittering
ColdBox knows what a tweet is.

The winner of ColdBox Training is...
Conrad Davis...sorry to spoil the suspense.

Fusebox
How to Drive Fusebox 5.5
Sean Corfield announces that Jeff Peters new book through Proton Arts is available.

LightWire, CFTemplate
Testimonials: Using LightWire, CFTemplate a version of IBO or any ideas from ...
Peter Bell is looking for some testimonials to use on his visa request.

Mach-II
New Documentation: Using the Threading Adapter Package and Utility Connector
Peter Farrell posts about some new documentation on the wiki.

Mango Blog
Introducing SmartType Mango Blog Plugin
Adam Tuttle released this plugin which replicates the Smart Dashes plugin for WordPress.

OnTap
OnTap Framework adds new documentation, google group and Wiki
The official onTap framework (http://on.tapogee.com/) site now has blog-style comments on every page, including the documentation, a Google group (ontapogee) and a wiki ( http://ontap.wikispaces.com ).

Razuna
Razuna Subversion Repository now open
SixSigns has opened up the Rasuna SVN repository to anonymous access.

Skweegee
Skweegee Private Beta - Sign Up Quick
Russ Johnson is opening up his Trac-like project to a private beta.

Skweegee Is NOT Dead!! New Screenshots and Private Beta
Russ Johnson posts some screenshots of his Trac-like project and discusses the private beta.

WhosOnCFC
It's Been a Busy Week
Shane Zehnder discusses some of his work on a Transfer-powered version of WhosOnCFC.

WhosOnCFC Going DB
Shane Zehnder announces that he will be porting WhosOnCFC to use Transfer ORM.

Tutorials, Presentations and Reviews

CF Groovy
Hibernate for CF (and a new TransactionAdvice)
Barney Boisvert discusses using his CF Groovy project with Hibernate.

CFWheels
Weekend Reading: New Documentation
The new version included a whole lot of new documentation.

ColdBox
Quick Tip: Reload Coldspring in Coldbox without Reinitilaizing
Tom DeManincor offers this tip.

Coldbox and resource bundles
Andrew Scott posts some thoughts on adding multilingual support into the ColdBox framework.

DataMgr
DataMgr Overview
John Whish covers Steve Bryant's presentation to the Devon CFUG.

FarCry
Installed FarCry Tonight: First Impressions
Brad Wood discusses his installation and first impressions of FarCry.

Mach-II
Mach-II Breadcrumbs filter
Matt Williams shows how to use his breadcrumbs plugin.

Mango Blog
Friendly URL's for Mango Blog with ISAPI_Rewrite 3.0
Mark Aplet posts about getting ISAPI_Rewrite and IISPassword working on his Mango Blog site.

Model-Glue
Ask a Jedi: Making use of ColdSpring/Model-Glue and Remote Proxies
Raymond Camden answers a question about calling servcie methods from a cfajaxproxy.

Model-Glue, ColdSpring
Model Glue, ColdSpring, and a Webservice
This tutorial discusses using ColdSpring to create a remote proxy of a service to use as a webservice.

Model-Glue, Transfer, ColdSpring
Java 1.6 u10 gives big boost to Model-Glue/Transfer/Coldspring performance
Brian Ghidinelli notes a 23-48% performance improvement by moving to the Java 1.6 u10 RC.

MXUnit, ColdSpring, ColdMock
My Approach to Test Driven Development Part 2 - MXUnit, Coldspring and ColdMock
Paul Marcotte offers this tutorial.

OnTap
10 Questions for Isaac Dealey on the OnTap Framework
Kay Smoljak interviews Isaac Dealey for SitePoint.

Transfer
Transfer's getMemento() has Changed
Bob Silverberg points out that if you were using the undocumented getMemento() method in Transfer, it has changed.

eSeminar Recording: What's new in Transfer 1.0 (and 1.1?)
Mark Mandel posts a recording of a recent presentation.

Easy Access to Primary Keys in Transfer Objects
Bob Silverberg updates his AbstractTransferDecorator.

My First Steps With Transfer : Day 3
Shane Zehnder looks into handling many-to-one relationships with Transfer ORM.

My First Steps With Transfer : Day 2
Shane Zehnder examines building his gateway components with Transfer.

My First Steps With Transfer : Day 1
Shane Zehnder learns how to create the Transfer XML configuration.

Maintaining Text Selection Visibility in a Flex TextArea

Here's what appeared to be a simple problem, which in the end had a simple solution though with a long path to find it (thanks to Zoe Bloch for pointing me in the right direction). Basically, I needed my TextArea's to maintain the visibility of the text selection even when a user clicks on something else. Under normal circumstances, the selection remains, but isn't visible unless the TextArea has focus. However, the TextField class has a property called alwaysShowSelection that keeps the selection visible, though greyed out a bit, even when the TextField doesn't have focus. Well, TextArea seems to use a internal TextField to render the text but it doesn't make this property accessible. If you extend TextArea, however, you can access it. Here's how.

First of all, to see the behavior I talking about, view my example here. In it you can select text in myTextArea subclass (which, for lack of creativity, I call SelectionTextArea) as well as in a standard TextArea. After selecting some text, click on the button or the ComboBox and you will notice the text in the standard TextArea doesn't appear selected (though if you tab the focus back you will see it still is) while the selected text in SelectionTextArea remains visibly selected.

All my subclass includes is a call to set the alwaysShowSelection property of the TextArea's internal TextField to true. This is done on CreationComplete because prior to this the TextField variable is null. The full code for the class is below. As you can see, there's not much to it (and if you AS/Flex gurus have improvement suggestions, feel free).

package com
{
import mx.events.FlexEvent;

import mx.controls.TextArea;

public class SelectionTextArea extends TextArea
{
public function SelectionTextArea()
{
super();
addEventListener(FlexEvent.CREATION_COMPLETE,setAlwaysShowSelection);
}

private function setAlwaysShowSelection(event:FlexEvent):void
{
textField.alwaysShowSelection = true;
}
}
}