Simplify Threaded Processing with FutureThreadedWorker

Having worked with both Groovy, (J)Ruby and, Java and (to a much smaller degree) Clojure, I can pretty easily claim that ColdFusion's threading and distributed processing capabilities.. leave a little to be desired. (Okay, actually a whole lot).

There are solutions though - using a job queuing system like Amazon SQS, IronMQ, or if you are looking for a something more threaded, dig into Marc Esher's awesome cfconcurrent project.

But sometimes you just want to take an array of values and run them through some sort of processing in a threaded manner, without having to jump onto any other projects or infrastructures, and without having to write that nasty <cfthread> create and join pattern for the millionth time.

So I wrote a quick CFC I've called 'FutureThreadedWorker', which does exactly that, without half the code you would otherwise need. (Note: this was written for ColdFusion 9. It would be a bit nicer if I could use closures)

<cfscript>
   //create, passing in an array for the array of structures (which are the arguments passed to the workerMethod)
   //then pass it the worker to call the worker method on
   //tell it how many thread it's should use
   //finally, tell it the name of the method to invoke.
   var future = new services.util.FutureThreadedWorker(queue, this, 5, "doWork");

   //start the running
   future.run();

   //if I want the results, wait for them.
   var results = future.get();

   //if i want to check for errors
   var errors = resuls.getErrors();
</cfscript>

Bam. That's it.  The FutureThreadedWorker now loops around the passed in array, and passed in the arguments to the method specified on the worker without you having to worry about creating threads or joining them back up again. I think you'll find that a lot easier than using <cfthread>.

cf.Objective(ANZ) is only a Month Away!

Wow, time flies!

Seems like only yesterday I was doing the closing remarks on the last cf.Objective(ANZ), and now it's already around the corner.

This year is going to be great once again, with lots of top notch speakers and a program that is going to be really interesting as well!

The sessions that I'm personally looking forward to are:

Functional Programming with Clojure & CFML - the best of both worlds?
I'm personally getting more and more into functional programming (or even just writing my OO code with more of a functional style). It's definitely something that is picking up steam all over the place, so I'm keen to see what Kai has to say.

Railo CLI
I'm doing a lot of (J)Ruby work these days, and I'm pretty much living in the console with the great tooling it has in this department. I'm really keen to see what advancements that Railo has made in this area, and see if there are opportunities there for cross pollination.

Building the Olympics
This should have some very interesting war stories of a site that is truly web scale.

Using nginx With ColdFusion
I've always been intrigued by nginx as I've seen it used in many places, but never looked into it itself. I know people that swear by it, so I'll be interested to learn more about nginx.

The Ugly Truth about Frameworks
This is just going to be fun :)

What sessions are you guys looking forward to?

ColdFusion 10 with Ubuntu Upstart

Setting up ColdFusion 10 on an Ubuntu Server, and as per usual, the installation option to start up ColdFusion when the server starts does not work on Linux.

So I wondered how hard it would be to set this up using Upstart, and it was surprisingly easy with a few bit of trial and error.

This is what I would eventually came up with:

Unfortunately, I would like this to respawn if it somehow dies, and it doesn't look like this style of setting up will work for that.

Anyone else tried this? What did you come up with?

cf.Objective() 2012 Slide Decks

In case anyone would like access to them, here are my slide decks for the two presentations that I gave at cf.Objective() this year.

The first one is Getting closure on Closures - this can be run directly from ColdFusion 10, as a html slide deck which includes the running code.

The second one, A/B Testing with Squabble can also be found online. I made this pubic because Sean Corfield asked me to, but in all honesty, if you weren't at the presentation, it probably won't make much sense to you. Pictures of Storm Troopers in front of computer screens are not particularly descriptive.

Overall cf.Objective() was a great confidence, yet again, much kudos to those that organised the event!

ColdFusion 10 and Closures: The Sesame Library

Writing my presentation for cf.Objective(), Getting closure on Closures, I found I was writing a few common utility functions for use with Closures to use and show in my talk, and as general utilities for coding.

I wanted to bundle these functions into a project, and put it on Github so that we could all share various utility functions that would be useful now that ColdFusion has got Closures available to us. I went looking for an existing project that was already doing this, but since I couldn't find one, I figured I would start one, and see what happens from there!

The project's name is Sesame (much thanks to Ben Koshy for the name), and currently only has a few functions which can be cfincluded into your code, but they were the ones I found most useful when doing some recent work with Groovy, and wanted to have them on hand when doing similar things in ColdFusion.

Here are a few examples:

From the collections include, the _collect functions allows you collect values from one array or struct, by iterating a closure over the passed in collection, and collecting the results returned from that closure.

For example, if I wanted to get all the names from an array of Employees, I could do the following:

var employees = listEmployees();
var names = _collect(employees, function(employee) { return employee.getName(); } );

This would then give me an array of all the employees name in the list.

My other favourite, is _groupBy(), which gives you an easy way to group an array or struct of items into a structure of items that have been grouped by a value returned from a closure.

For example, I could easily group an array of employees by their salary, like so:

var employees = listEmployees();
var grouped = _groupBy(employees, function(employee)
              {
                 if(employee.getSalary() < 100)
                 { return "Less Than 100"; }
                 else if(employee.getSalary() > 100 && employee.getSalary() < 200)
                 { return "Greater than 100, Less than 200"; }
                 else
                 { return "Greater than 200"; }
              });


From there, I can now get at all the employees that earn less than 100, by referenceing them as grouped["Less Than 100"], and so on.

From the numbers include, I really like the _times() function. Simply put, it executes a closure a certain number of times!

_times(6, function() { writeOutput("Write me 6 times!"); });

Nothing too complicated there, but it can be quite useful.

From the concurrency include, there is a function that was directly inspired by the GPars Groovy library (and awesome concurrency library for Groovy). _eachParrallel() will execute the closure for each item in an array or struct, but execute the closure in its own cfthread implementation, allowing for an easy way to parallel process data. When it is done, it joins all the threads back up again, so there is no need for you to do deal with managing the threads yourself.

For example, summing up each item in an array, each in it's own thread:

var values = [1, 2, 3, 4, 5];
var total = 0;
_eachParallel(values, function(it) { total += it; });

Gives us a total of 15.

If you find this interesting, please feel free to download, use and also contribute. I know there are a million more functions that could yet be implemented, and I've already implemented the automatic documentation generator - so as long as your functions have appropriate hinting, it becomes super easy to regenerate the README.md file! So no hard work there.

I'll also be showing this library off as part of my cf.Objective() talk on Closures - so please pop by if you want to see more about closures in ColdFusion 10, or just about closures in general.

JavaLoader 1.1, and a Move to GitHub

A couple of new items in this release of JavaLoader:

• A few bug fixes in the NetworkClassLoader that allowed the Tika library to work.
• A new function for switching out the ThreadContextClassLoader.

The new function, swithThreadContextClassLoader() is useful as it is often required when dealing with libraries, such as dom4j, that use the ClassLoader to define singletons or search for implementing classes, and don't allow you to overwrite what ClassLoader they use. Check out the wiki for more details on why this is neccessary, and how easy it is to now do, thanks to our new function!

Also, JavaLoader has been move to GitHub, along with the all the documentation. This should make collaboration much easier moving forward!

Otherwise, make sure to sign up to the mailing list, and enjoy loading your Java.

Speaking at cf.Objective() 2012!

I'm delighted to say that I'm speaking at cf.Objective() again this year!

I've got three sessions I'm presenting this year, two of which on my own, and one in which I'm paired with with Luis Majano.

I'll be talking about:

A/B Testing with Squabble

In which I extol the virtue of A/B testing, and why you should be doing it in your business, and introduce people to the A/B testing framework Squabble that we developed to use in the team I work with.

Getting closure on Closures

Where we will look at Closures, which are coming in ColdFusion Zeus. You probably already use these, and don't even know it. I'll explain what closures are, and how you can use them in simple ways, as well as more interesting use cases as well.

AOP Demystified!

This is the session I will be doing with Luis Majano, where we will talk about Aspect Oriented Programming, and give you examples with the two primary AOP frameworks - ColdSpring and Wirebox. Should be good stuff!

All up, it looks like it's shaping up to be a great conference program, so I look forward to seeing everyone there!

Custom Schemas in Coldspring 2

One of the most powerful new features in Coldspring 2 is the ability to create custom xml schemas that can be used within your XML configuration.

Rather than go into the details of how to write and configure custom schemas, here is an example of one that comes bundled with CS2 out of the box.

In Coldspring 1.x, if you ever wanted to create a standalone structure inside your XML configuration, you would quite commonly create it through a MapFactoryBean like so:

<bean id="myMap" class="coldspring.beans.factory.config.MapFactoryBean">
<property name="sourceMap">
    <map>
        <entry key="keyA" value="keyA value"/>
        <entry key="keyB" value="keyB value"/>
        <entry key="keyC" value="keyC value"/>
    </map>
</property>
</bean>

This is all well and good, but the issue here is that you specifically need to know the api of the MapFactoryBean.  If you get any part if the configuration of the MapFactoryBean wrong, you tend to get errors that may not be clear, or potentially no error at all, simply a result that is not desirable.

For example, if you misspell the sourceMap property, Coldspring will attempt to set the property, but it doesn't throw an error when it fails.

<bean id="myMap" class="coldspring.beans.factory.config.MapFactoryBean">
<property name="sourcMap">
    <map>
        <entry key="keyA" value="keyA value"/>
        <entry key="keyB" value="keyB value"/>
        <entry key="keyC" value="keyC value"/>
    </map>
</property>
</bean>

Therefore, all you will get back is an empty struct, and quite possibly a headache trying to debug exactly why this is happening in your code.

In ColdSpring 2, there is a nice, convenient util  custom schema, that exists to do things like create arrays, lists and other data structures for you.  It essentially is a simple wrapper around things like the MapFactoryBean, but the custom schema gives you a code completion and hinting when using an XML editor (that support XML Schemas), as well as better error messages when things go wrong.

So, for example, if I wanted to do exactly the same configuration as above, I would add the xml namespace for util in the head of my xml file, like so:

<beans xmlns="http://www.coldspringframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:util="http://www.coldspringframework.org/schema/util"
        xsi:schemaLocation="http://www.coldspringframework.org/schema/beanshttp://coldspringframework.org/schema/coldspring-beans-2.0.xsd
        http://www.coldspringframework.org/schema/utilhttp://coldspringframework.org/schema/coldspring-util-2.0.xsd ">

Which would enable the <util:> namespace in my XML editor, and I could quickly type out:

<util:map id="myMap">
        <entry key="keyA" value="keyA value"/>
        <entry key="keyB" value="keyB value"/>
        <entry key="keyC" value="keyC value"/>
</util:map>

And we would have the same result as above, but if something went wrong with your syntax, the IDE should show you what it was, and if it didn’t, you would get a nice error from the XML validation letting you know exactly what it was.

Of course, the whole point of this post, is due to the extensible nature of ColdSpring, you can write your own custom XML namespaces, and register them with your XmlBeanFactory, to do things in very concise and easy to use manner inside your IDEs as well.

This is a very simple example of what can be done with Custom xml schemas. You can drastically change the nature of the BeanFactory as well as the contained beans through this mechanism, but this should hopefully give you a little bit of a taste of what can be done with this new functionality.

ColdSpring 2 is available on GitHub

This is something I did a while ago, but for whatever reason, totally forgot to announce publicly.

Thanks to the power of distributed version control, there is a copy of the Git repository for ColdSpring 2 on Sourceforge, as well as one on GitHub.

It goes without saying that GitHub really is the best place for Open Source projects to manage and allow for collaboration with other developers, so it makes sense to have a copy of ColdSpring 2 on GitHub as well.

So get your forks ready, and make some pull requests! :)

ColdDoc 1.0 Release (and a move to GitHub)

ColdDoc is one of those projects I don’t work without these days. No matter the project, I’ve always got a stack of CFCs in it, and I need a way to document what objects I have, and what methods they have on them. A great example being the ColdSpring 2 project.  I’ve got my local Jenkins install hooked up to generate the ColdDoc documentation on each run, and I usually run it locally often while developing, so I have an up to date reference of what methods are available to me, without having to dig into actual CFC code.

ColdDoc has been ready for 1.0 release for quite a while, but has yet to be formally pushed out into the wild.

With a little push from behind from @vanderwoud, I got my planned migration of ColdDoc to GitHub into gear, and all is now complete.

Now ColdDoc is hosted on GitHub, which is great, because it really is the best place to allow for community contributions, as well as the documentation ported over into the Wiki.

ColdDoc 1.0’s big new ticket item is interface support (although it doesn’t support multiple interface inheritance), as well as lots of little bug fixes.

So if you are ready to get your automated documentation on, grab a copy of ColdDoc, run it against your current code base, and see what comes out!

And if you have any contributions you would like to make to ColdDoc (and I’m sure there are some out in the wild), please issue a pull request against the repository.

ColdSpring 2 Documentation Competition - Win a Copy of CFBuilder!

With the rewrite of ColdSpring , a whole load of documentation also needed to be ported, and in some cases, actually written for the first time, for existing functionality as well as new functionality.

Unfortunately it became a real sticking point with getting a release of ColdSpring 2 out of the door.

While the documentation isn’t quite complete, there is enough there to get people started, and it can be fleshed out on a case by case basis.

That being said - to help make the documentation complete as quickly as possible, there is now a competition to win a copy of ColdFusion Builder, and the way to enter is to write documentation for ColdSpring 2.

The rules are very simple:

• To enter, you have to write a page of documentation for ColdSpring 2.
• You can write multiple pages, for more chances to win.
• Entries can be submitted directly to the Trac Wiki, in Word or OpenOffice format and emailed to me directly (email below), or to the ColdSpring Google Group.
• Some pages are easier than others, so best to get in early (some are just ports/extensions from the existing documentation).
• Possible pages are the pages that are empty on the Wiki (unless you come up with some new section that is deemed to be an missing item).
• A documentation page must be approved on completion to be an entry (i.e. no 2 line entries, etc trying to game the system).
• The competition closes on the 31st of November (Australia time!), and the winner will be randomly selected from the entries, and a copy of ColdFusion Builder will be sent to the winner!

To make this more enticing, and also a whole lot easier, I’m offering each person who wants to enter my Skype and IM details.

Skype: mark_mandel
Gtalk & MSN: mark.mandel@gmail.com

I’m happy to have a 10-15 minute voice chat with potential entrants explaining a feature if they are new to it and/or guiding them in what I had in mind for the documentation page, and give whatever other advice they need via IM and email to help them complete their documentation page.

So not only is this a chance to help out the ColdSpring and ColdFusion community, it’s a chance to win FREE copy of ColdFusion Builder, and also it’s a great opportunity to pick my brain on ColdSpring 2 (which should hopefully be worth something as well  :) ).

ColdSpring 2 Alpha 1 Released

After a long 2 years of development, ColdSpring 2, Alpha 1 is ready for release!

It’s been a long road getting here, but with the rewrite of ColdSpring, means that ColdSpring 2 comes with a stack of new functionality that should help you out with all your dependency injection needs, and then some!!!

To give you a quick overview of some of the major new functionality that comes with ColdSpring 2:

XML Schema For ColdSpring

No more needing to guess what XML to write with ColdSpring, or use a not-quite-right-fit Spring.dtd or XSD to give you code completion and hinting with your XML.

Now with a XML editor that supports XML Schemas (Eclipse Web Tools Project jumps to mind) and a quick XML schema declaration at the top of your XML, you now get total code-completion, and built in help with your XML elements. Makes life much easier!

AOP Custom XML Namespace and AOP Expressions

This is one of my favourite features, as it just make Aspect Oriented Programming with ColdSpring and absolute breeze.

Gone are the days of ProxyBeanFactories and NamedMethodAdvisors. Now you have a simple scripting language for defining where you want Aspects to be applied, and what you want them to do.

For example, if I had the following XML:

<beans xmlns="http://www.coldspringframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.coldspringframework.org/schema/aop"
   xsi:schemaLocation="http://www.coldspringframework.org/schema/beans http://coldspringframework.org/schema/coldspring-beans-2.0.xsd
   http://www.coldspringframework.org/schema/aop http://www.coldspringframework.org/schema/coldspring-aop-2.0.xsd"
   >

   <!-- AOP configuration -->
   <aop:config>
      <aop:aspect ref="timer">
         <aop:around method="timeMethod" pointcut="execution(public * *(..))"/>
      </aop:aspect>
   </aop:config>

   <bean name="timer" class="com.Timer" />

   <bean name="fooService" class="com.FooService" />

</beans>

What this says is, for the given pointcut, execution(public * *(..)), which translates to any method execution, which is public, and returns any variable, with any method name, and any number of arguments (i.e. every method), call the method timeMethod on bean timer around that method.

So when do call fooService.doSomething(). Our Timer Component, will be able to log how long it took, and as you can see, no need for complicated ProxyBeanFactories, target beans or anything of the sort. All nice and clean and concise.

This is by far, just the surface of what is possible with the AOP XML namespace and AOP expressions in ColdSpring. There are more configuration options, and many more different types of expressions that are possible.

ColdFusion 9 ORM Integration

Injecting other objects into your ORM Entities can be a tricky prospect, but ColdSpring 2 comes bundled with a stack of utility objects that make this much easier, as well providing you with additional functionality to help you out with common ORM tasks as well.

ColdSpring 2 comes with a BeanInjectorEventHandler, whose job is to intercept when Entities are loaded, and inject them with whatever dependencies are loaded.

To intercept when new Entities are created, ColdSpring 2 has a SessionWrapper object that provides an interface to the underlying Hibernate Session, from which you can request new Entities, list, save, delete Entites and much more.

The SessionWrapper also enables some more advanced configuration options above and beyond ColdFusion’s basic settings, including being able to set a default Hibernate Session Flush Mode, and implementing a strict transaction mode as well.

This is just a start to the ORM integration, there is plenty more bundled into ColdSpring 2!

Multiple Bean Scope Support

ColdSpring 2 has a totally new and reworked bean creation process, so that not only can it create transient and singleton beans, but it can also tie beans to request and session scopes as well. To do this, it has a new scope attribute which replaces the old singleton attribute on beans.

Therefore to define a bean as a singleton, you not define:
<bean id=”fooService” class=”com.FooService” scope=”singleton”>

To define a  transient bean:
<bean id=”fooService” class=”com.FooService” scope=”prototype”>

To define a request scoped bean:
<bean id=”fooService” class=”com.FooService” scope=”request”>

(And I’m sure you have the pattern by now) To define a session scoped bean:
<bean id=”fooService” class=”com.FooService” scope=”session”>

This gives us even more control over the life-cycle of our beans, to enable some very powerful capabilities in our applications!


There is a lot more to ColdSpring 2 than just the above, but hopefully that will give you enough of a view to entice you to take the framework for spin.

More details can be found in the Release Notes, ColdSpring website, and Trac site.

Also, if you are interested in going into the running for winning a copy of ColdFusion Builder, check out the ColdSpring documentation competition currently running to aid in fleshing out the rest of the documentation for ColdSpring

How I Configure ColdFusion ORM and Why

I’ve been reading quite a few mailing list posts on ColdFusion based ORM, and I find that I’m seeing a lot of repeats on what configuration settings people are generally using when setting up ORM in their Applicaiton.cfc, and why they should use certain settings.

I figured it would be useful if I wrote down how I like to have my base configuration of my Application.cfc in regards to ORM, and also take a step by step look through why I set things up the way I do.  Hopefully this will help out a few people when they first start out with ORM, and are looking at all the different options for ORM in ColdFusion.

<cfscript>
   this.datasource = “mydatasource”;

   //orm settings
   this.ormEnabled = true;
   this.ormSettings.cfclocation = expandPath("/model");

   this.ormSettings.automanageSession = false;
   this.ormSettings.flushatrequestend = false;

   this.ormSettings.useDBForMapping = false;

   this.ormSettings.autogenmap = false;

   if(isDevEnvironment())
   {
      this.ormSettings.dbcreate = "dropcreate";
      this.ormSettings.sqlscript = expandPath("/import.sql");
   }
</cfscript>

So breaking this down line by line.

this.datasource = "mydatasource";

This isn’t specifically an ORM setting, but I love how in CF9, we can set a default datasource across the application in one place. Also like that ORM picks this up too, although it can be overwritten with ormSettings.

this.ormEnabled = true;

Again, nothing special. We turn on ORM. Without this line, nothing happens.

this.ormSettings.cfclocation = expandPath("/model");

When ORM is enabled, by default, ColdFusion will scan from your web root, looking for any CFC’s that are marked as persistent. As a performance enhancement, it’s useful to tell it specifically what folder to look at.  Also, if you have your components stored in a mapped directory, this is the only way it can be done.

I’ve seen this set a few ways (dot notation, relative paths), and seen a fair few people have issues with this. Personally, I’ve never had an issue when using the expandPath(), so I stick with that as the way to go.

this.ormSettings.automanageSession = false;
this.ormSettings.flushatrequestend = false;

I bundle these two together because they are quite related in what they do. They basically control how the Hibernate session works in ColdFusion ORM. This combination of settings does the following:

• Turns off the Hibernate session being flushed at the end of the request
• Stops the Hibernate session being flushed at the beginning of a transaction
• Stops the Hibernate session being cleared when a transaction is rolled back

For me, this is very, very, very important. The default setting of having these both on for ORM makes doing basic things with ORM very easy, but when you start getting into more complex scenarios, in which issues like object validation or concurrency arise, these default settings can throw some fun Hibernate exceptions on your screen super fast.

By setting the above to false, you have complete control over when a session will flush (only when a transaction commits), and you know it will only be cleared when you request it to be. This makes it a lot easier to manage your Hibernate object states in those more tricky scenarios.

(You can use ormFlush() with the above settings, but please don’t do that. Please use transactions. Your database will thank you.)

this.ormSettings.useDBForMapping = false;

This is primarily a performance setting. By turning this off, it stops ColdFusion from going out to your database and looking at what tables and columns you have and attempting to generate it’s object mappings from there. Personally I can’t stand this functionality, as your DB then drives you model (not an ideal scenario), and also because, if you are using annotations / HBMXML config files, there is absolutely no reason to do this (and I’ve read of people on Oracle having crazy issues with having this enabled by default as well).

this.ormSettings.autogenmap = false;

This setting is most definitely a personal preference thing. When I work with ORM I use the HBMXML mapping files, as every time I use the annotations, I find it doesn’t default the way I would expect/want, or I am looking to use some Hibernate functionality that isn’t exposed through annotations. Then I have to go back and move all my configuration from annotations to a HBMXML file. It’s far easier to me to start with a HBMXL file, and never look back. Since I also have a CFBuilder extension to help generate the stub files, it makes it an easy decision.

Setting autogenmap to false, means that even if someone were to come along and use annotations, they wouldn’t work, so it makes sure I don’t have that "Just this once I’ll do annotations..." thought which inevitably leads me back to rewriting annotations into HBMXML again.

this.ormSettings.dbcreate = "dropcreate";
this.ormSettings.sqlscript = expandPath("/import.sql");

This setting is more for greenfield projects. On legacy projects, I find that they tend to frown on having all their development data dropped, for obvious reasons, and it can be a large project to write an import script for it all.  However, when starting from scratch, it’s really nice to have a clean data set on every reload, especially from a unit testing perspective.

There are many more settings that can be used, that are generally more application specific, such as the SQL dialect, or whether or not you enable the second level cache, but this is generally speaking, the base configuration I start most project from.

Using ColdFusion Frameworks for Application Development - Recording

If you managed to miss my talk on Using ColdFusion Frameworks for Application Development, you can catch the recording here.

I really enjoyed giving this talk, but it wasn't until I was well into the talk that I realised how much there was to cover (didn't feel like that much during practice!). I'm sure I missed several of people's favourite frameworks, but I attempted to cover the basic set (as I saw it at least), and mention as many other ones as I could to give people a feel for what was out there, and give them a place to start when choosing a single, or set of application frameworks

The whole week featured some really great talks, so if you are looking for the rest of the talks, you can see all the recordings listed here for your enjoyment.

Big thanks to Adobe for hosting the event, and Simon Free for spearheading the efforts!

ColdFusion Frameworks for Application Development @ ColdFusion Developer Week

Next week I'm proud to (slightly belatedly) announce that I will be doing a presentation entitled Using ColdFusion Frameworks for Application Development at next weeks online ColdFusion Developer Week.

We will cover a basic introduction to Model-View-Controller, Dependency Injection and Object Relational Mapper concepts, as well as take brief looks at each of the major frameworks that are available for ColdFusion in these areas.

By the end of the presentation, you should (hopefully) have a better idea of what framework options are out there for you as a ColdFusion developer, and give you a sense of which frameworks may suite your particular application, or your development style.

Registration Open for cf.Objective(ANZ) + Flex

In case you missed the hullabaloo, registration recently opened for cf.Objective(ANZ) + Flex.

I'm really excited about this years speaker line up, and honestly think that the sessions we have this year are the best we've ever had. We got awesome content on testing, frameworks, continuous integration, version control, and more. Basically, if it's used in enterprise software development, I think we've just about got it covered.

We've also got four pre-conference workshops also lined up as well, so there is an extra opportunity there to get some extra learning in, on top of the pretty incredible line up of speakers we have as well.

It should be noted that there will be no extensions on the early bird for cf.Objective(ANZ) + Flex, so make sure to get your registration in early!

As you can tell, I'm really excited about this year's conference, so I look forward to seeing you all there!

cf.Objective(ANZ) + Flex - Call for Speakers

cf.Objective(ANZ) is Back Again - This Time with More Flex

cf.Objective(ANZ)  is back again for another year, with it's usual two tracks of amazing enterprise ColdFusion goodness, as well as a whole new dedicated Flex and Flash track.

No where else in Australia and New Zealand will you be able to get this type of delicious ColdFusion learning, combined with a sumptuous feast of front end Flex and Flash content, so make sure to mark your calendars now!

Check the cf.Objective(ANZ) website  for details including dates and venue.

Also - if you are interested in sponsoring, download the sponsorship guide, which can be found on the sponsors page . 

 

Tip for ColdFusion Builder - Adding a New Server via RDS

Something I (somehow) worked out a while ago for adding a new ColdFusion server in ColdFusion builder, that I'm not sure is widely known.

Adding a new server to ColdFusion Builder can be a bit of a pain, as you have to remember / work out a stack of details about the server, and make sure you get it 100% correct when enterting the details into all the boxes.  This can be even more complicated if you have a JEE install of ColdFusion, and/or are working with remote servers.

There is actually an easier way baked into Builder already!

1. Go to Windows > Preferences > RDS Configuration (or through any one of the RDS views) and create a RDS connection to the server in question.
2. Go to the Server View, and click 'Add a Server'. This will now give you the option of importing from an RDS connection. Do that.
3. You should now have all the fields of the Server pre-populated for you, for a connection.
4. Add in any extra configuration you like from here - virtual hosts, folders mappings etc.
5. You are now done.

Isn't that easier?

I'm speaking at the cf.Objective() keynote

A little late to the party, but I'm really honoured to announce that I was invited to speak for part of the keynote at cf.Objective() in this year. I'll be joined by such venerable cohorts as Ray Camden, Scott Stroz, Jason Dean and Bob Silverberg, so it should be a great time all around, and we may even learn at thing or too as well.

Don't also forget, there are the Lighting / Pecha Kucha talks at cf.Objective() again this year. These talks are a great way to get your feet wet for presenting at a conference, and can also just be a whole load of fun, so if you are interested, sign up right away.

Either way, I look forward to seeing everyone at cf.Objective(), it's going to be a great time!

Speaking at cf.Objective() and Starting a Podcast

Lots of stuff I should have been blogging about, but haven’t managed to find the time.

First of all, I’ve been accepted to speak at cf.Objective() this year, which is a great honour.

I’m doing  talk on AOP For you and Me , which will be an extended version of the talk I did at Adobe MAX and cf.Objective(ANZ) , wherein I will talk not only about what Aspect Oriented Programming is, but also go more in depth into some real world examples.

I will also be presenting ColdSpring 2.0 Alpha 1 - What's New and Improved? In which I will discuss all the new doodads and whoogama-whatsits that come in this new version of ColdSpring , which is currently only 3 tickets away from code completion!

As per usual, I’m really looking forward to this conference. It’s always a fantastic time, and a great learning opportunity.

Also, my good friend, Kai Koenig and I, decided it would be fun to start up a podcast! (Well, he basically bullied me into it, but ssshhhh). We gave it a test run, and it was lots and lots of fun. We’re planning on talking about all sorts of Adobe stuff, ColdFusion, software engineering, and whatever else grabs our fancy.

We set up a website at http://www.2ddu.com/ , and will be posting updates there, and you can also follow the podcast on twitter @2dduPodcast . Our first installment is up there now, and please give us any feedback you have - we would love to have it.

Query Caching with Script Based Queries

I could not get query caching to work for me with Query objects, and I couldn't work out why for the longest time.  For example:

<cfscript>
    local.query = new Query(sql="select * from holidays",
                            datasource="myDS",
                            cachedWithin=createTimespan(0, 1, 0, 0));

    local.result = local.query.execute().getResult();
</cfscript>

No matter how many times I refreshed this test script, the SQL result would never cache.

The reasons why didn't click until I kept looking at the query output:

qryname49118 (Datasource=myDS, Time=1ms, Records=8) in /opt/coldfusion9/CustomTags/com/adobe/coldfusion/base.cfc @ 16:19:14.014

select * from holidays

Since I didn't need to set a name for the query, as I had a query object, the Query.cfc was giving the underlying <cfquery> a unique name on each and every call.  Since the name was unique, when ColdFusion went to look to see if the query was cached, it never found anything for that query name.

Changing the above query to:

<cfscript>
    local.query = new Query(name="test",
                            sql="select * from holidays",
                            datasource="myDS",
                            cachedWithin=createTimespan(0, 1, 0, 0));

    local.result = local.query.execute().getResult();
</cfscript>

Suddenly means the query is cached, and all is well again in the world, as the name of the query is explicitly set.

It would be great if the name of the query was a md5 hash of the SQL that is being passed in, and then at least you wouldn't have to bother naming the query something specific if you want to use the query cache. In the mean time, if you run into this issue, you now know how to work around it.

Trying the CFML Plug-in on IntelliJ

For a long time I’ve been meaning to try out the the IntelliJ CFML plug-in for two reasons. One of which, I’ve always heard really good things about the IntelliJ platform for editing Java, Groovy and Flex, and also because as a Linux based ColdFusion developer, my CFML IDE options are limited.

So I decided I was going to get some work done on JavaLoader, to move it into a 1.0 Final, and I was going to do it all in IntelliJ with the CFML plugin, and use that as a way of seeing how the CFML plugin was going.

Installation
Installation was the biggest hurdle for me, as I ran into a lot of issues getting the plug-in installed and running.

From what I could see, IntelliJ makes no mention that you need to set a JDK_HOME variable in your environment. Except when you first run it and get an error message. Once that was done however, it fired up with no problems at all.

For whatever reason, after running IntelliJ, the CFML plug-in didn’t show up in the plug-in list.  If it had, I’m sure things may have gone a lot smoother for me.

I then browsed to the plugin page, to download the plug-in manually.  Two things went wrong at this point.

1. As far as I could see, IntelliJ does not describe anywhere how to install a plug-in manually. This is the only documentation I could find on installing a plug-in, and it was via the plug-in manager (see above), so it was not very helpful. It is very simple, you just unzip it and put it in the /plugins folder.
2. I downloaded the wrong plug-in for my version on IntelliJ. I downloaded 9.03 Ultimate edition, or if you look in the build.txt file that comes with IntelliJ, that’s Build IU-95.429.  Unbeknownst to me it’s that build number that is used on the plug-in download page (See Since build and Until build ) that define what a plug-in is compatible with. Honestly I am confused as to why they don’t just use the IntelliJ product number, but maybe there is a good reason.

(Apparently this has since been fixed, and you can now install from the plug-in manager again)

Appearance
My first thought when opening IntelliJ was “Wow, this is ugly”. I’m used to working in Eclipse, and the Linux build of Eclipse takes the Ubuntu theme that is currently set very nicely. So much so that people at conferences often ask me how I get my Eclipse to look the way it does.  In IntelliJ, the text wasn’t even anti-aliased.

I quickly found an Appearance setting, and switch the theme over to GTK+, which I expect made IntelliJ use Ubuntu native GTK rendering engine, and suddenly IntelliJ matched my Ubuntu theme, and was much more pleasant to look at.  Eclipse still looks more polished, but maybe that’s just because I’m used to it.

Documentation
This is where things fall down, unfortunately rather hard.  The only documentation for the CFML plug-in is a blog that can be found here and a google group .  This project is in desperate need of a website/wiki/Google doc/anything that has some sort of structure. Skipping through blog posts and searching the google group in an attempt to find that one piece of knowledge you need is frustrating, to say the least.

Creating a Project
I go to create a project, and... there is no ColdFusion Project. Uh oh.  Fire off an email to the group and ask “What do I do now?”. (Update, I just got told to create a Java project. Weird, but it works).

In the mean time, I switch tacks, and import an existing Eclipse Project.  IntelliJ asks me for a JDK, but is happy enough when I skip over it, figuring I wouldn’t need one for a CFML project.  That worked quite well, and I’m now on my way to editing ColdFusion.

Editing Files
Code completion for variables and functions inside a CFM and/or CFC is one of the biggest priorities for me, and in the plug-in, I have to say, this feature works very well.

That being said, one thing that is missing for variable completion for me, is completion for variables such as arguments , application , server , CGI , etc, for which there are already bugs for.  That and CFC resolution is missing, which Builder does for things like createObject() etc, (somewhat).

Interestingly enough there is no “New CFM” or “New CFC”, there is only “New File”, which I didn’t find myself missing, except for when creating CFCs.  The new CFC dialogue in builder is great, and if you’ve ever worked with interfaces, having Builder generate the method stubs for you is pretty cool as well.

Overall, the responsiveness is very snappy, and code completion comes up almost instantly, which is very nice. I prefer the function hinting in IntelliJ to Builder, as it give you the hint per parameter as you are inside the method, where as Builder only tends to give you the tooltip when you first write the method.

While I didn’t get to play with it, there is also support for code completion of Java objects , including when being used with JavaLoader , which is not something ColdFusion Builder can do.

Live Templates
This is more of a IntelliJ thing, but Live Templates blow CF Builder/Eclipse Snippets out of the water. Wow.  I love being able to define a $FOO$ variable in my snippet and declaring that $FOO$ variable to complete(). IntelliJ then intelligently provides all the code completion that would normally show up if I hit ctrl+space at that point. I think I’m only just scratching the surface of what is possible with Live Templates, but this feature is fantastic.

Learning Curve
IntelliJ does some things differently to Eclipse, which takes a little while to get used to.  That being said, you can switch the keyboard commands to Eclipse style with a menu change (I did some extra tweaking above and beyond that), so that is nice.

Price
The CFML plug-in only works on the commercial version of Intellij. Licences for personal use carries a price tag that is fairly similar to ColdFusion Builder. Corporate licences cost a fair amount more.  For the functionality provided by the CFML plug-in at this stage , I would recommend that if you are on Mac/Win, stick with Builder. You will get more bang for your buck.  If you are on Linux, and refuse to move OS’s (like I am), IntelliJ is well worth an evaluation, as the price tag is very reasonable, and if you are looking to do Groovy, Flex or Java work, IntelliJ already has that functionality bundled in.

Overall
I have to say, once I got over the initial hurdles of installation, and documentation, and became more comfortable with IntelliJ as a whole, it because a really nice IDE to work in.  There are plenty of rough spots around the edges, but I think with a few more revisions, this plug-in could easily be a decent contender for ColdFusion Builder (especially if it gets a debugger).

If you are looking to purchase an IDE, I would still say stick with ColdFusion Builder for now if you are on Mac/Windows, but if you are on Linux, and don’t want to move, IntelliJ looks like a dark horse to watch in the ColdFusion IDE space.

Learning More
If this has piqued your interest, the best place to really learn about this plug-in is the google group, so sign up there. The blog is also good for information about new releases and what new features are available.

cf.Objective(ANZ) Student Ticket Giveaway

Our wonderful sponsor Fasthit has kindly provided us, not only with a ticket to give away to a student living in Australia or New Zealand, but is also paying for flights and accommodation as well for the lucky winner.

The rules are simple:

1. You must be an Australian or New Zealand Resident
2. You have to have a valid student identification.
3. You must be under 25 years of age.
4. You need to send an email to contest@cfobjective.com.au, with no more than 200 words stating why you would be the best person to win this competition.

...and that is really about it.

The winner with the best entry will be announced on the 1st of September.

If you are a student, make sure you enter for a chance to win! If you aren't a student, but know someone that is, make sure to pass on the message.

For more details, have a look at this news post.

cf.Objective(ANZ) 2010 in Full Swing

There has been so much going on with cf.Objective(ANZ), that I haven't even had time to blog about it!

In case you missed the announcements, the pricing is now online, with the early bird price being lower than last years, at $749.00 including GST, valid until the 31st of August.

There are a series of 1 day workshops the day before the conference as well, covering ColdFusion Performance tuning, Flex 4 and ColdFusion, and Arduino hardware with ColdFusion.  Charlie Arehart, Kai Koenig, and Justin McLean are running these workshops respectively, and you couldn't ask for better instructors.

While each track of the 2 day conference has yet to be finalised, almost all of the sessions that will be available are now online , and we have some fantastic content again this year, with some speakers that I am very excited about.  The usual slew of amazing ANZ dignitaries will be joining us, also with international speakers such as Gert Franz, Mark Drew, Mark Blair, Mike Brunt and Tim Buntel (Or maybe 'semi-international' would be a better fit? Mark Blair moved to San Francisco and then came back, Tim Buntel now lives in Sydney... ;o) ).

I'm really happy with the way this conference is coming together this year, and providing some really unique ColdFusion content for the ANZ region.  We've got some great training, some great speakers, some great sessions, it's looking like it's going to be a fantastic time all around.

Adobe MAX Pre-Conference - Getting Started with ColdFusion 9 ORM

Bob Silverberg and I are back at it again, with a one day pre-conference lab at Adobe MAX this year covering an introduction to Object Relational Mapping in ColdFusion 9.

As the description states:

Learn about one of the most compelling new features in Adobe ColdFusion 9 from two seasoned ColdFusion veterans. This release includes the integration of Hibernate, an enterprise-class, Java based ORM. Join us to hear how to get started using ColdFusion 9 ORM features in your next project. Through interactive learning and hands-on labs, we'll start with the basics and work together to add features to an application that takes advantage of the ORM. Then we'll discuss best practices and potential pitfalls, making this an ideal combination of introductory material and tips and tricks.

If you are interested in getting your feet wet with ColdFusion 9 ORM, you can get more information on the MAX pre-conference page .

Hope to see you there!

Dzone RefCard - Leveraging ColdFusion 9 Exposed Services from Java

In ColdFusion 9, several Web Services come pre-built with the product, allowing greater interoperability between different technologies and ColdFusion.

The other day saw the release of my Dzone RefCard outlining how you could take advantage of these Web Services from Java, and use ColdFusion's

If you are doing Java development, and are looking to integrate some of ColdFusion's capabilities into your application, you can download the RefCard from here .  It will step you through setting up the Services, generating the required Java code to run the Web Services, and also provides examples of usage to help you get started.

You can also read more about ColdFusion Web Services here .

Presenting ColdSpring 2.0 on CFMeetup.com

On 6pm US ET, Wednesday May 19 I will be presenting Dependency Injection Redefined - ColdSpring 2.0 to the CFMeetup Crowd.

For those of us in more southern parts of the world, that is 8:00am, the 20th of May, Australia.

This is the same talk I recently gave at cf.Objective() and WebDU .

Synopsis:
ColdSpring 2.0, codename Narwhal, is a complete rewrite of ColdSpring aiming is to provide a far more extensible architecture and many more features above and beyond what is currently provided with ColdSpring to date. These new features will give developers the capabilities to build and manipulate this Inversion of Control framework in fascinating and very powerful ways, thus saving them even more time when managing their dependencies and utilising functionality such as Aspect Oriented Programming.

In this presentation we will look at the new features of ColdSpring 2.0, both complete and envisioned, including functionality such as extensible schema support, events for bean life-cycles, enhanced AOP support, annotation support, and much more.

More details and rsvp can be found here .

Look forward to seeing you there!

Some arguments against "Linux users don't pay for software"

As many people probably know, I'm a huge proponent of Linux operating systems, most specifically Ubuntu, not only because its open source, and free, but mostly because I honestly believe it's the best operating system I've ever come across.

For obvious reasons, I spend a bit of time trying to convince a variety of people that Adobe should take a serious look at bringing Adobe products to Linux, the most notable being ColdFusion Builder.

One argument (and there are a few) against this, I hear over and over is this idea that "Linux Users don't pay for software".


Recently, however, the "Humble Indie Bundle", was put up for sale, in which 5 cross platform games (Win, Mac, Linux) were sold together as a group. The real time data for sales and the operating system splits has been shared, providing us with a wonderful aggregate data about the difference between Win, Mac and Linux users, how much they are willing to pay for software, and if they are willing to pay at all.

The fun part of this experiment was that the customer could choose how much they paid for the bundle, which could be as little, or as much as people liked.  It also could be split any way between the developers, charity, or charity and the developers.

Some interesting stats to note (Taken from the real time stats as of this moment):

1) Current intake across Win, Mac, and Linux - $1,173,536 (which is just cool in and of itself)
2) Windows has the largest market share (no surprise there), with 86670 purchases.
3) Linux is the smallest number of purchases, with 21873 purchases, but that is only 8153 purchases, less than the Mac platform - 30026
4) The big news here is that Linux people paid more on average than either Mac, or Windows users.

I don't think you can ask for a better experiment than this.  If Linux users wouldn't pay for software, then they would be at the bottom of the list in terms of amount paid. Instead that's where Windows users sit.

Details of the Humble Indie Bundle can be seen here:
http://www.wolfire.com/humble

Their realtime JSON feed can be found here as well:
http://www.wolfire.com/humble/stats

(And they are some cool games as well)

On another note, Valve have announced that they are releasing their Steam Source Code client to Linux. This is a huge boon to the Linux community, and while there are no dates yet, obviously Valve thinks there are people in the Linux community who will pay for software, otherwise they wouldn't be putting in the time and effort.

Therefore, you can quite clearly see that Linux users will, and do pay for software, and in fact put a higher cost on software than any other OS's user base.

I claim this myth well and truly busted.

ColdSpring Framework on Twitter

Just a note to let everyone know I set up a twitter account for ColdSpring.

It has automated updates for Git commits, and ticket events. It should be a good resource for helping people keep up to date with the going-on's of ColdSpring, and especially ColdSpring 2.0.

Follow coldspring_fw on Twitter!

ColdSpring 2.0 - Now On SourceForge

Up until recently, the goings-on of what has been happening in ColdSpring 2.0 has been fairly limited to my twitter account.

The first thing to note, is that the code name for this project is Narwhal. Why Narwhal? Basically because they are awesome. They roam the ocean with a huge spike attached to their head, which can be used to impale, seals, penguins, and apparently also koalas. See - awesome. (Who really has reasons for code names?)

The next most interesting thing to note, is that much of ColdSpring's infrastructure is now hosted on Sourceforge, as it provides a large feature set for us to leverage. Here you can find the project page, which gives you access to the Git repository that contains the code for ColdSpring 2.0.  Sourceforge also provides hosting for the Trac install that is being used to host our documentation and tickets and milestones.  We are currently investigating options for integration with the current ColdSpring website.

I'm not going to go into new features in Narwhal, of which there are more than a few (I have to have some incentive for people to come to my my WebDu Talk!), but documentation has started on the Wiki, and will be expanding quickly in the future (If anyone wants to help with that, the more the merrier!).

You may also note that much of the documentation is also being generated automatically, in an attempt to alleviate some of the burden of authoring.  Now that there are XMLschemas being used, HTML documentation is being generated from them, and ColdDoc is also being used to generate API documentation for the underlying architecture.

It's still very early days for ColdSpring 2.0, but a Alpha1 does loom on the horizon. That being said, the Git repository is public, so feel free to pull it down, have a look at what is happening in the Unit Tests, what documentation is available, and feel free to discuss it on the mailing lists.  Just beware - this is still pre-Alpha, so the sand may shift under your feet as new code gets produced, bugs get quashed and new features get developed.  You have been warned!

More details coming soon!

Back from cf.Objective() 2010

I'm back home again from what I would like to say was, one of the best cf.Objective()'s I have ever been to, including the fact that I was incredibly ill for the last day of the conference. I only managed to catch two sessions in the afternoon, and otherwise was holed up in my hotel room either fast asleep, or feeling particularly sorry for myself.

There are many things I would like to prescribe the incredibly high quality of the conference to, but the the high calibre of the session presentations really stands out at the main contributor.  I believe that when the session quality of a conference is so high, the attendees are excited and motivated by new ideas, which directly translates into fantastic and thought inspiring hallway conversations, and everything continues to flow from there.

To make a few particular references to presentations I particularly enjoyed -

Easy and Flexible Validations for Objects - Bob Silverberg
I had not previously taken the time to look at Bob's ValidateThis framework, but let me just say this: It is slick!  I was very impressed by what was possible with very little configuration, and the the flexibility that was available. My hat is off to Bob for his work with this validation framework.

Continuous Integration with MXUnit, Ant and Hudson - Marc Esher
Marc is always a very entertaining presenter, and this presentation was no exception.  I've used Hudson with MXUnit before, but it was still fantastic to see Marc explain this technology in a very clear and easy to understand manner.  He also gets points in my book for using the Hudson Chuck Norris plugin.

Polyglot Programming - Barney Boisvert
If anyone has read Barney's blog, they should already know that he's a super smart fellow.  This presentation only solidified this fact, in which Barney dug deep into the very compelling reasons a developer should potentially look into developing with multiple languages at a time (something as web developers we are doing already).  Barney covered some really interesting points about language design, the intent of programming code and qualifying return on investment in regards to polyglot programming. All great stuff!

Running ColdFusion on the Amazon EC2 Cloud - Chris Peterson
This was a session I really wanted to attend, but unfortunately I slept through due to illness.  I wanted to make note of it, as I was told that Chris had a completely filled room, and I've been told it was a really interesting presentation all around.

Building Advanced Workflows with ColdSpring - Dan Skaggs
I don't believe I have had the opportunity to see Dan speak before this, but this presentation was an eye opener!  I came to this presentation with my 'ColdSpring Lead Developer' hat on to see what interesting things people were doing with ColdSpring, and came away with a new found respect for the framework itself, and the ingenuity that Dan was displaying in his use of it.  Dan walked us through how his company was using ColdSpring to dynamically configure application workflow and processing - which enables it to be both incredibly flexible in its implementation and amazingly easy to maintain. 


All in all, a great conference all around.  See you all again next year!

ColdFusion ORM Training + Java Persistance with Hibernate = Awesome!

No more Linux scripts for ColdFusion Builder

A few people have asked me about the ColdFusion Builder scripts for Linux for the new 1.0.

I'm sorry to say that I won't be doing a script for ColdFusion Builder on Linux for the 1.0 release.

I tried this morning to run my usual scripts to get a plugin install out of ColdFusion builder, which ran fine, but after installing and attempting to run it, I was met with a dreaded:

!ENTRY com.adobe.ide.editor.cfml 4 0 2010-03-23 09:39:50.110
!MESSAGE

Whenever I opened a CFML file (which doesn't tell me much about what is going on where).

There is obviously something native built into ColdFusion Builder 1.0, that wasn't present in Beta 3 (I can see some .dll's etc), which is causing this error to occur.  Adobe have also done the right thing, and removed all the debugging so that would be hackers have a hard time working out what is going on where.

If you want to get involved in evangelising ColdFusion Builder on Linux, there are some things you can do:

1. Vote for the bug!
2. Vote for the Flash Builder bug too (if they do one, they will have to do the other!)
3. Bug your evangelists! (But do it in a nice way)  Conference season is coming up, so have a chat with them when you see them around, and let them know that you would buy a copy for Linux.
4. Run it in VMWare / VirtualBox
   
5. Change your OS of choice (ECH!)
   

At the end of the day, I'm only upset about there being no Linux version, because I think ColdFusion Builder is a great product, and I want it to have as much exposure as it can.  We need to convince Adobe that the Linux market is a viable one, and will have a good return on investment.

If I hear of any changes in the Linux landscape for ColdFusion Builder, I'll be sure to let you know.

cf.Objective() ColdFusion 9 ORM Training

I believe it is time for some shameless self promotion!

If you were looking for more information on the ColdFusion 9 Object Relational Mapping Training that the venerable Bob Silverberg and I are putting on at cf.Objective() next April, we have just fleshed out the content section of our site to include a detailed outline of the topics that we will be covering during the training program.

You'll know Bob from his blogging at http://www.silverwareconsulting.com/, on a variety of all too clever stuff, including CF9 ORM, Git, Unit Testing, and ValidateThis - his own open source validation framework.  He's also an all-around nice guy

You'll see that we cover a variety of topics with ColdFusion 9 ORM that will allow you to hit the ground running once you have completed our training, and it will be taught in a clear, step by step manner that will leave you wondering why you ever thought the term "Object Relational Mapper" sounded so scary and complicated.

So if you are keen on expanding your skill-set with ColdFusion 9, and specifically with its integrated ORM, we think this is the course for you, and we hope to see you at cf.Objective()!

cf.Objective() Preconference Classes

ColdDoc 1.0 Alpha Released

When ColdDoc was first born, the original idea was to just output a port of Javadoc.  Looking into it further, I realised that the mechanics where there to generate any sort of documentation, not just a static HTML version of the API.

To that effect, ColdDoc has been refactored so that it is possible to generate documentation based on an arbitrary Template Strategy.  ColdDoc now ships with both a strategy that generates the port of JavaDoc and a strategy that generates UML via the UML2 Tools plugin in Eclipse, and plans are in the works to generate a PDF document strategy as well.

I won't take you through implementation details (there is new documentation for that), but you can still generate the static HTML API documentation based on JavaDoc, for which you can see an example here, but now it is done through the HTMLAPIStrategy. This also includes support for new ColdDoc based annotations, in which, for example, you can specify generic types for return/arguments types like array, struct etc, so you can finally answer that question in your documentation of "Yes, but what does that array contain?".

When working on the ColdSpring 2.0 rewrite (wow, that is long overdue for a blog post), I also really needed a way to generate UML diagrams from the code I was writing, as a basic attempt to be able to roundtrip from UML->CFC and then back again.  Also included within ColdDoc is a strategy to generate the XML that the Eclipse UML2 Tools Plugin uses to create UML diagrams from.  You can see a screenshot of a Class Diagram here that has been created with this combination of tools.

This is very useful, as it becomes very useful for collaboration and software design sessions, even when you have started with UML diagrams, as software designs can shift during implementation phases, and diagrams and documentation often fall by the wayside during these rapid change cycles.

If you are interested in more, or possibly developing your own documentation generation strategies, download a copy of ColdDoc, read the new documentation, and join the conversation on the google group.

Happy automation of documentation!

ColdFusion 9 ORM and Transactions - It Does Not Mean What You Think it Means.

In one of my favourite lines from the Princess Bride -

[Vizzini has just cut the rope The Dread Pirate Roberts is climbing up]
Vizzini: HE DIDN'T FALL? INCONCEIVABLE.
Inigo Montoya: You keep using that word. I do not think it means what you think it means.

..and when using Transaction support with ColdFusion 9 ORM and Hibernate Sessions...It did not do what I thought it did. It did something else.

To give some back story: As we have discussed previously, a Hibernate Session is meant to flush at the end of a Hibernate marked Transaction.

So if we are talking to Hibernate natively (for example set up with JavaLoader), and had the following code:
mySession = sessionFactory.openSession();

foo = mySession.get("Foo", 1);
foo.setBar("fooBar");

trans = mySession.beginTransaction();

mySession.save(foo);

trans.commit();

mySession.close();
Which then translates to the following:

1. Start a Hibernate Session
2. Retrieve Entity 'Foo', with a key of 1, and assign it to a variable foo
   
3. set the property 'Bar' on foo
4. Start a Hibernate Transaction, which is tied to the Hibernate Session
5. Tell the Hibernate Session to save() our Entity foo
6. Commit our Hibernate Transaction, which will flush the Hibernate Session
7. Close the Hibernate Session

If we attempt to do the same thing in ColdFusion, it may look something like this:

foo = EntityLoad("Foo", 1, true);
foo.setBar("fooBar");

transation {
    EntitySave(foo);
}

Which you would think would work exactly the same as above. Except or one small thing - It Doesn't.

If you read the ColdFusion Documentation on ORM Transactions, it states:

When <cftransaction> begins, any existing ORM session is flushed and closed, and a new ORM session is created. The <cftransaction> can be committed or rolled back using appropriate ColdFusion tags in <cftransaction>. When the transaction ends and has not been committed or rolled back explicitly, it is automatically committed and the ORM session is closed. If there is any error inside the transaction, without any exception handling, the transaction is rolled back.

This means that the above ColdFusion code, will actually perform like so:

1. Start a Hibernate Session with the ColdFusion Request
   
2. Retrieve Entity 'Foo', with a key of 1, and assign it to a variable foo
3. set the property 'Bar' on foo
4. Hit the start of the Transaction, flush the current Hibernate Session, close it, and then start another one.  At this point, foo has been persisted to the database, and is now detached (and remember detached is generally bad)
   
5. Call EntitySave() on the now detached object foo
6. Commit the Hibernate Transaction, and flush the Hibernate Session
7. Flush the Hibernate Session, when the ColdFusion Request Ends
   

Or if you want to look at it another way, it would be the equivalent of doing the following native communication with Hibernate:
mySession = sessionFactory.openSession();

foo = mySession.get("Foo", 1);
foo.setBar("fooBar");

//foo actually gets persisted to the DB at this point
mySession.flush();
mySession.close();
mySession = sessionFactory.openSession();

trans = mySession.beginTransaction();

//foo is now detached
mySession.save(foo);

trans.commit();

mySession.flush();
mySession.close();

The big question at this point, is of course - Well, why does ColdFusion do it this way then?

There is actually a very good reason, although that reason (imho) is based on a few assumptions. 

The first assumption, is that you are going to write your ORM interactions inside your transaction block, like so:

transation {
    foo = EntityLoad("Foo", 1, true);
    foo.setBar("fooBar");

    EntitySave(foo);
}

The second  assumption is that, as a developer you will leave the ORM setting flushatrequestend set to its default of true, and therefore a split between the Hibernate Sessions is required.

For example, if we had the following code:

transation {
    foo = EntityLoad("Foo", 1, true);
    foo.setBar("fooBar");

    myMethodHereThrowsAnException();

    EntitySave(foo);
}

If we didn't have separate Hibernate Sessions, or at least clearing of the Session after Hibernate Transaction rollback, , the following would occur:

1. Start a Hibernate Session with the ColdFusion Request
2. Start the Hibernate Transaction
   
3. Retrieve Entity 'Foo', with a key of 1, and assign it to a variable foo
4. set the property 'Bar' on foo
5. Throw an exception, which causes the Transaction to rollback
6. The request ends, the Hibernate Session is flushed, and foo gets saved back to the database, since it is still available in the Hibernate Session.
   

Presenting and Teaching at cf.Objective() 2010

I'm a little behind the times on this blog post - but I am presenting and also teaching a course at cf.Objective() this year.

I will be presenting 2 sessions at the conference:

Dependency Injection Redefined - ColdSpring 2.0: Narwhal

ColdSpring 2.0, codenamed 'Narwhal', is a project that has been going on a little 'behind the scenes', except for the occasional tweet from either myself, or Chris Scott.

In this presentation, we'll look at some of the motivations behind the complete rewrite of ColdSpring for the 2.0 version, and some of the new features that will be available that should make dependency injection easier, and way more flexible than ever before.

I've had in my to-do list a reminder to write a long blog post on what is going on with Narwhal, which I should write at some point soon, so you have a good idea what to look out for.  That being said, Narwhal is taking shape nicely, and I think is going to be a very powerful addition to the ColdFusion framework landscape.

Advanced Java & ColdFusion Integration with JavaLoader 1.0

This talk will focus on the new features of JavaLoader 1.0, and how you can use them to integrate Java with your ColdFusion platform in some new and exciting ways.  If you are interested in JavaLoader 1.0, check out this previous blog post, it gives you a good run down on the new features it brings to the table.

We will also be investigating some of more common 'gotchas' with Java and ColdFusion integration, especially around ClassLoader issues, which should be useful for all involved.


Bob Silverberg and I are also going to be a teaching a 2 day training course, just before cf.Objective():


This will be as very hands on session, where Bob and I will be going through building an application using ColdFuson 9's Object Relational Mapper from beginning to end.  This will include many best practices, discussions as well as theory about how the underlying Hibernate engine works with ColdFusion.  No ORM/Hibernate experience necessary.

More detail on the course can be found on our website, and also on the preconference page, where you can also check out all the other fantastic training content.

Don't forget that the early bird pricing for both conference tickets, and training finishes on the 29th of January, which is coming up soon!

cf.Objective() is looking to be a great conference. Hope to see you there!

JavaLoader 1.0 Beta 2 Released

This release of JavaLoader 1.0 includes the following fixes and enhancements:

• Performance improvements in loading classes
• Fix syntax so that JavaLoader 1.0 can be loaded on ColdFusion 7
• Extend the documentation

If you aren't aware of the new functionality in JavaLoader 1.0, you can have a look at my previous blog post , the documentation and/or the presentation I did at MAX for more information.

Credit and thanks to Fred Roeber for his contributions to the NetworkClassLoader in JavaLoader.

If you are interested in hearing more about ColdFusion and Java integration please come to cf.Objective(), where I will be presenting on Advanced Java & ColdFusion with JavaLoader 1.0.

In the mean time, download JavaLoader, and please report any bugs that you find.

ColdFusion Builder Beta 3 on Linux

ColdFusion Builder 3 is up on Labs , and available for download, so it's now time to update my scripts for getting it up and running on Linux.

The procedure is as following:

1. Download the intermediate build *for MAC* (very important! The Windows Adobe Licensing will prevent you from using the Windows version any more, as it uses .dll files, and those don’t work on Linux, but the Mac version works on Linux!)
2. Download coldfusion_builder_b3.zip .
3. Unzip coldfusion_builder_b3.zip into a directory
4. Unzip coldfusionbuilder_b3_install_mac_121709.zip
5. Unzip /cfbuilder_install.app/Contents/Resources/cfbuilder_install.app/Contents/Resources/Java/Disk1/InstData/Resource1.zip (may be easier to do that into another folder)
6. From the unzipping of Resource1.zip grab /Z_/dist/_macos_87b1877cbdff_zg_ia_sf.jar and put it in the same folder as where you unzipped coldfusion_builder_b3.zip
7. Run ’./Rip.py’ from the folder you unzipped it to.
8. You should now have a ’plugins’ and ’features’ folder with just the bits you need to install into Eclipse.
9. Enjoy CF Builder in Linux :D

Enjoy!

My Interview on Dzone - ColdFusion and Java Integration

The interview I did with Dzone at the Adobe MAX conference is now online!

In the interview we talk about a variety of topics, mainly centred about how and why to integrate ColdFusion and Java together, but also touching on things like Object Relational Mappers, including ColdFusion 9's integration with Hibernate.

Hope you like it, and please give it a nice 'up' on Dzone.

Code Samples for Rapid OO Development with ColdFusion Frameworks

You can download the full code samples I used in my Rapid OO talk that I gave most recently at cf.Objective(ANZ) , and previously at cf.Objective() .

Before people ask, I don't tend to post slides, as they are generally only pictures, and tend to have no context without me talking next to them.

That being said, I'll have a chat with the CFMeetup crew, and see if they would like me to give the presentation there, so there is a recording for posterities sake, and for those who couldn't make those conferences.

One Week Until cf.Objective(ANZ)

I can't believe it was well over a year ago I was sitting around with the steering committee of cf.Objective() , and the conversation turned to 'What do you think of the idea of doing this conference in Australia?', it feels just like yesterday.

Now we're only one week away from cf.Objective(ANZ)!!!

If you haven't already registered , there are still spots available, so make sure you grab them quick! You don't want to miss out on hanging out with super-top-programmers like Justin McLean , Andrew Muller , Dan Wilson ... oh, and did we mention Ben Forta and Terry Ryan are coming? (like anyone missed that!).

See you all in a week!

JavaLoader 1.0 Beta Released

JavaLoader 1.0 is moving from Alpha to Beta with only a few small bug fixes and enhancements.

If you are not familiar with JavaLoader 1.0's functionality, you can have a look at my previous blog post , the documentation and/or the presentation I did at MAX for more information.

The was a logic bug in the way that dynamic compilation was occuring across multiple source directories that has now been resolved, and should also ensure that compilation is much faster than it was in the Alpha.

The other enhancement was to allow for relative paths in the Spring integration.  To explain, in the Alpha, you would often end up having to input your beans similar to this:

<coldfusion:cfc id="message"
        script-source="file://${root.path}/model/Message.cfc"
        script-interfaces="com.IMessage"
        />

Which can be a bit of a pain, as injecting a dynamic value for ${root.path} is not as easy in Spring as it is in ColdSpring.

Now, by default, 'script-source' attributes are relative to the calling page, so you can do your bean definitions like this:

<coldfusion:cfc id="message"
        script-source="file:///model/Message.cfc"
        script-interfaces="com.IMessage"
        />

and the path will be worked out for /model/Message.cfc relative to your application path.

Oh, and don't forget - if you are into integrating Java and ColdFusion development, make sure you sign up for the Google Group !

JavaLoader 1.0 Beta can be downloaded here .

MAX Presentation Recording: ColdFusion for Java Developers

I had the wonderful opportunity to present and attend MAX for the first time ever this year, and I can honestly say, it was a fantastic time all around.

MAX is completely unlike any other conference I've ever attended, both in terms of its sheer size, and also in terms of the wide gamut of Adobe community members that are in attendance.  I managed to meet a variety of people that I would never have talk to in my regular travels both in term of physical locations and also technological disciplines.

I also had the pleasure of presenting the last session on the last day, so I was very happy when I had a fairly reasonable turn out for my ColdFusion for Java Developers presentation.  The presentation took the perspective that the attendees were/are already doing Java development, but want to port those tools and codebases that they are already using to a ColdFusion environment, so they could take advantage of ColdFusion services and language.  From there we look at the variety of techniques that you can use to enable ColdFusion->Java communication, as well as Java->ColdFusion.  This includes a aan overview of a lot of the JavaLoader 1.0 feature set in the process.

If you are one of these people, and/or you are doing development in both ColdFusion and Java, you can watch the recording of my presentation on Adobe TV .  You may want to skip the first 5 minutes, as for some reason the recording has me doing all my set-up before I start speaking.

ColdFusion Builder Beta 2 on Linux

For those of you who have been running ColdFusion Builder on Linux, you may have noticed that the installer structure has changed since the last public beta, which means that my previous instructions will no longer work.

This means we have to jump through some different hoops to get things to work this time around.

The steps are now the following:

• Download the Windows version of ColdFusion Builder
• Download my cfbuilder_builder.zip file and unzip it somewhere
• Unzip the windows installer like so: 'unzip cfbuilder_windows_public_beta2.exe'
• Under InstallerData/Disk1/InstData/ you will find Resource.zip
• Unzip Resources.zip
• Under Resource1/Z_/dist/ you will find _windows_fe4d6d02bcbb_zg_ia_sf.jar
• Copy _windows_fe4d6d02bcbb_zg_ia_sf.jar to the same directory you unzipped cfbuilder_builder.zip to (and should now have Rip.py and plugins.txt in it)
• Run 'python Rip.py', and wait.
• You should now have 2 folders in that directory 'plugins' and 'features', which you can now copy into your eclipse directory to do a plugin install.

As new versions of ColdFusion Builder become public, I will attempt to keep this script up to date.

 

Ben Forta is Coming to cf.Objective(ANZ)!

In case you missed the tweets, I am very pleased to announce that Ben Forta will be joining us in Melbourne, Australia for cf.Objective(ANZ) !

Ben will be joining ColdFusion Evangelist Terry Ryan to represent Adobe ColdFusion here in Australia, and the two of them will be around to chat to all attendees about ColdFusion and the Adobe ecosystem.

Don't forget that the early bird price comes to a close on the 12th of October, which is fast approaching, so please make sure you get yourself registered so you can take advantage of it.

See you all when I get back from MAX.

Talking Java and ColdFusion Integration on CFPanel this week!

This is obviously a topic that is quite near and dear to my heart, but it is also one that I think often doesn't get its 'surface scratched' (so to speak).  In my experience I often see the information presented is more on the 'how to get set up' side, and less on the deeper details on what can actually be done.

I'm really looking forward to getting a chance to share experience with the other CFPanel members, and really get deeper into some interesting Java and ColdFusion integration, in regards to how people are using it, what benefits they are reaping, and also what problems they have encountered.

For more details, and and all the other time zones, check out the CFPanel post.

Hope to see you in the Connect room!

Registration Opens for cf.Objective(ANZ)

It's been a bit of a bumpy road getting here, but registration for cf.Objective(ANZ), being held in Melbourne Australia on the 12th and 13th of November is finally open!

The program is full with a stack of really interesting presentations, ranging from JVM Tuning and Optimisation, to ModelGlue 3: Gesture, all the way to Connecting hardware up to ColdFusion!

We have an international cast of speakers, including notable luminaries such as Dan Wilson and Mike Brunt, as well as many talented speakers from the Australia and New Zealand Regions, including Geoff Bowers, Robin Hilliard, Kai Koenig and many, many more.

Helping organising a conference over international borders has been quite the learning experience, however I am very proud to be part of the steering committee that is bringing cf.Objective(ANZ) to the Pacific Region.

If you are looking to learn about enterprise development, and hang out and talk to a slew of like minded developers for two days, register for the conference, and come on down!  It's going to be a great time!

JavaLoader 1.0 Alpha is Released!

JavaLoader 1.0 is a project I've been talking about off and on for the past 6 months or so, and I'm very happy to announce that a release version is now complete.

There are several key new features to JavaLoader 1.0,

Dynamic Compilation

Now if you are working with JavaLoader, you don't have to bundle your Java code into a jar to load.  You can simply specify to JavaLoader which directories are your source directories, and JavaLoader will compile and load them on the fly for you!  JavaLoader will also check to see if your source code has changed, and re-compile it as necessary! 

For example, if I wanted to compile and load a HelloWorld.java (that has a simple 'Hello World' method) in my ./src directory, I could do:

javaloader = createObject("component", "javaloader.JavaLoader").init(sourceDirectories=[expandPath('./src')]);

And then create my HelloWord object as per normal:

<cfset helloWorld = javaloader.create("HelloWorld").init()>
<cfoutput>#helloWorld.hello()#</cfoutput>

No more ANT tasks, no more export to .jars, JavaLoader handles the compilation and deployment of your Java code for you.

ColdFusion Component Dynamic Proxy

For those of you who are not aware of what a Dynamic Proxy in Java is, it is essentially an Object that can mimic an object that implements a given set of Interfaces.  The method invocations against that object are intercepted, and you can essentially do whatever you like with them.

In JavaLoader 1.0, I've written a Dynamic Proxy that you are able to wrap around a CFC, and thereby make Java Objects think they are interacting with a native Java object, but are in fact, talking to your CFC.  When a Java Object calls a method on the Dynamic Proxy, it is passed through and invoke directly on the CFC transparent to your Java layer.

For example, the java.lang.Thread Java object can take an instance of the interface java.lang.Runnable in its constructor argument.  Using JavaLoader's Dynamic Proxy, we can pass it what it thinks is an instance of the Runnable Interface, but is in actuality a ColdFusion Component like so:

//give us access to the CFCDynamicProxy
CFCDynamicProxy = javaloaderloader.create("com.compoundtheory.coldfusion.cfc.CFCDynamicProxy");

//create my Runner CFC
myRunner = createObject("component", "MyRunner").init();

//wrap it in a Dynamic Proxy, that implements Runnable
runnerProxy = CFCDynamicProxy.createInstance(myRunner, ["java.lang.Runnable"]);

//pass it to the Thread and call run()
thread = createObject("java", "java.lang.Thread").init(runnerProxy);
thread.run();

...and suddenly we have true seamless communication from Java to ColdFusion components.

This is actually something I wish I had written three years ago.  It would have radically altered how I would have written a lot of software.

Spring Integration

A natural progression from the Dynamic Proxy, was to implement a Custom Schema in Spring, so that you could instantiate and dependency inject your ColdFusion components with your Java Objects inside Spring itself.

Initialising Spring with JavaLoader is covered in the documentation, but to give you a quick taste, once we have Spring running, we can include a CFC in our spring.xml with:

<coldfusion:cfc id="message"
        script-source="file://home/www/model/Message.cfc"
        script-interfaces="com.IMessage"
        />

Where script-source is the absolute path to the CFC you want to instantiate, and script-interfaces are the Java interfaces that your dynamic proxy will implement, and your CFC has mirrored inside it.

This Component then gets treated like a normal Spring bean, so it can be autowired, injected, aop'd and all the usual functionality that a Spring bean has access to.

There are some downsides to implementing Components inside Spring, so be sure to check out the documentation for more details.

Read More

For more details, have a read of the extended documentation, and have a look at the examples provided in the download.

Since this has become a far larger project than its original inception, I've done away with the Riaforge Forum, and have started a new javaloader-dev google group for support and discussion of JavaLoader and Java and ColdFusion integration.

While I'm very confident in the code that I have written for JavaLoader 1.0, I decided to call it an Alpha, simply because it has only really been tested by me and my Unit Tests.  Knowing from experience that users of Open Source Software have a tendency to use and abuse libraries far above and beyond what the author had ever originally dreamed led me to decide to call it Alpha until the community has really had a good change to play with it.

Please download JavaLoader 1.0, take it for a spin, sign up for the mailing list, and if you find any problems please do let me know.

Getting UTF-8 and MySQL to work with ColdFusion 9 ORM

A question I've seen show up quite often in Hibernate forums is 'How do I get Hibernate to generate UTF-8 Compliant Tables and/or columns when it generates my database tables when using mySQL?'

It's actually, quite easy to do, but often (myself included), people end up looking deep into Hibernate for some mysterious setting.

In reality, it's just a question of setting up your database correctly.  The first thing you need to do is set your database to use UTF-8 character coding as its default, like so, when creating it:

create database my_new_database default CHARACTER SET = utf8 default COLLATE = utf8_general_ci;

This will ensure all tables that are created by ColdFusion's ORM are created with a UTF-8 character set.

That being said, I have seen issues when data is being sent up to MySQL in UTF-8 form getting corrupted.  To ensure the database drivers use the correct character set as well we add useUnicode=true&characterEncoding=UTF-8 to our MySQL connection string in the ColdFusion Admin under the datasource's Advanced Settings.

There you go! UTF-8 support in mySQL with ColdFusion ORM!

Overloading ORM Implicit Get and Set Methods

This is something I just ran into with ColdFusion 9's ORM implementation, that thankfully Rupesh got back to me very fast on, otherwise, I probably would have been confused for quite a while.

I needed to overwrite a get and set value in a CFC I was creating.  We will say for arguments sake I was hashing a password on a User object (even though I was doing something completely different), like so:

component output="false" persistent="true"
{
    property name="userid" fieldtype="id" ormtype="int" generator="identity" hint="primary key";
    property name="name" type="string" notnull="true" length="200" hint="The user's name";
    property name="password" type="string" length="200" hint="The user's password";

    public void function setPassword(String password)
    {
        instance.password = hash(arguments.password);
    }

    public String function getPassword()
    {
        return instance.password;
    }
}

This is how I would usually have written my Components, storing my data in variables.instance, so they wouldn't overlap with any of the data stored in my variables scope.

What I couldn't understand was, my password would keep getting stored in my database as NULL, even though I had explicitly set it.

Thankfully Rupesh explained that when the ColdFusion ORM retrieves and populates data in an ORM managed CFC, it directly accesses the variables scope in the CFC.  So in the above instance, the ORM was finding no data for the password, and interpreting that to mean that I wanted to insert that as NULL into my database.

Therefore,  to get my code to work was to store my data in the variables scope, like so:

component output="false" persistent="true"
{
    property name="userid" fieldtype="id" ormtype="int" generator="identity" hint="primary key";
    property name="name" type="string" notnull="true" length="200" hint="The user's name";
    property name="password" type="string" length="200" hint="The user's password";

    public void function setPassword(String password)
    {
        variables.password = hash(arguments.password);
    }

    public String function getPassword()
    {
        return variables.password;
    }
}

This way the ORM can find exactly what it is looking for, and I can manipulate my data the way I want.

The fact that the ORM integration works this way is actually a very good thing, as it means that my password above doesn't get hash'd over and over again, but it is something we all should be aware of when you want to overwrite the implicit get and set functions that get generated by <cfproperty> declarations.

ColdFusion 9 ORM - Explaining Hibernate Object State

In the previous two articles, we started the discussion of Hibernate Sessions and how they related to the ColdFusion 9 ORM.  We noted the fact that a Hibernate Session keeps track of what objects it loads, and can therefore update it when it realises that the object has changed.  The question then posses itself - if a Hibernate Session has closed, which happens at the end of every ColdFusion request, what happens to the objects that it was managing?

Going forward, I'm going to reuse the Musician model I used in the Introducing ORM in Adobe ColdFusion 9 beta Adobe DevNet article, for which the updated code samples can be found here.

The very short version for those who don't wish to look at the code, is a model in which we have a Musician, who has a name, and an age, and he/she also has a many-to-many relationship to an array of Instruments, which they can play.

As far as Hibernate is concerned, there are three different states for any Object that it interacts with.

Transient

An Object/Entity (you could use either word) is Transient, if it has just been created with a createObject() or new operator, but has yet to be saved with the EntitySave() method.

Obviously, if transient objects are not persisted via EntitySave(), then they never get stored in the database, and will eventually be garbage collected.

For example, our musician john below is a transient object:

 

<cfscript>
    import com.*;
   
    //this is transient
    john = new Musician("Transient John");
</cfscript>



Since john is never saved, it will always be transient.

Persistent

A Persistent object is one that has either come from, or has been saved in the database, within the scope of the current Hibernate Session (which is an important point to note).

For example, we can make our musician john below persistent, by:

<cfscript>
    import com.*;
   
    //join is transient
    john = new Musician("Transient John");
    
    john.setAge(47);

    //john is now persistent   
    EntitySave(john);
</cfscript>

Therefore, since john was inserted into the database, he is persistet.

By the same token, if we retrieve an object through the ORM, it is also persistent:

<cfscript>
    //larry's ID is 2

    //larry is also persistent
    larry = EntityLoad("Musician", 2, true);
    
    //As larry is persistent, we can change his age, which will be reflected in the database
    larry.setAge(19);
</cfscript>



Since larry was retrieved from the database, he is also persistent.

Detached

Detached objects are ones that used to be persistent, but the Hibernate Session has closed. Detached objects were one of the biggest things for me to wrap my head around when starting with Hibernate, and can cause a few really tricky errors to occur.

To explain detached a little better, we can go through a scenario that will causes them, as I think this is something that a lot of ColdFusion developers are going to end up running in to.

Let's have a new musician, called Tim, and time is going to have 2 instruments that he plays, the Flute and Piano.

We are going to grab Tim out of the database, and then put him in our ColdFusion Session scope, so we can keep track of him from request to request.

<cfscript>
    tim = EntityLoad("Musician", 2, true);
    
    session.musician = tim;    
</cfscript>

For this request, Tim will be persistent, however, on the next request, Tim is now detached, as the Hibernate Session will have closed at the end of the previous request.

Therefore, if I do this:

<cfscript>
    instruments = session.musician.getInstruments();    
</cfscript>

<cfdump var="#instruments#">

You will see the following (not well written) error:

failed to lazily initialize a collection of role: Musician.instruments, no session or session was closed

If you are running ColdFusion via the console, you will also see something similar to:

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: Musician.instruments, no session or session was closed

What does this error even mean? 

First of all, we should remember that the collection of Instruments our Musician can play are lazy loaded. This means they aren't actually loaded from the database into the object until you actually request them.

The important thing to note here, is that lazy loading with Hibernate can only occur if the Hibernate Session that the object was originally loaded from is still open.  To put it another way, if the Hibernate Session has closed, then Hibernate has no record of what the object was doing, and therefore can't do any lazy loading.

In the above example, since the previous ColdFusion request ended, the Hibernate Session has closed, and if you attempt to access a relationship that is set to lazy load, and has yet to be loaded, this error occurs.

Its should be noted that singular properties are not lazy loaded - therefore, if you are just grabbing a property on an object that is detached, no error will be thrown.

What can we do to mitigate this issue? There are a few options, one of which is, to simply retrieve the object all over again, like so:

<cfscript>
    session.musician = EntityLoad("Musician", session.musician.getMusicianID(), true);

    instruments = session.musician.getInstruments();    
</cfscript>

<cfdump var="#instruments#">
Or, like so:
<cfscript>
    session.musician = entityLoadByExample(session.musician, true);

    instruments = session.musician.getInstruments();    
</cfscript>

<cfdump var="#instruments#">

As then the object we are dealing with is considered persistent, as it is attached to the currently open Hibernate Session.  This tends to be the easiest of the options when dealing with detached objects.

Another interesting way of making our detached object persistent is like so:

<cfscript>
    EntitySave(session.musician);

    instruments = session.musician.getInstruments();    
</cfscript>

<cfdump var="#instruments#">

This may look strange, but what is actually happening when you call EntitySave(), is that it calls the Hibernate method saveOrUpdate(). 

A quick version of what saveOrUpdate() does is -

• If the object being passed in is transient, INSERT it to the database.
• If the object is already persistent in the current Hibernate Session, do nothing.
• If there is already an object that represents the same Entity data persistent in the Session, throw an exception
  
• Otherwise, update the database with the information in the passed in object, and set its state to persistent.
  

Therefore in the example above, the data stored in session.musician will be saved again to the database, and since session.musician is now deemed persistent, we can successfully do lazy loading of the instruments.

However, if a situation like this would occur:

<cfscript>
    musicianTwo = EntityLoad("Musician", session.musician.getMusicianID(), true);

    EntitySave(session.musician);
</cfscript>

We get the following error:

a different object with the same identifier value was already associated with the session: [Musician#2]

Since Hibernate deems the persistent object that is currently connected to the Hibernate Session much more important than the detached object, which makes sense, as the persistent object has the most up to date version of the data stored in the database.

Generally speaking, if you at all can, try and avoid having detached objects in your application, as this is generally a Good Thing™, and will allow you to avoid some pretty decent headaches as you develop with CF9 ORM.  Strategies such as storing IDs in the ColdFusion Session and having an API to return a new Object by that ID on request is often a good way to go, rather than storing the Entity itself in the ColdFusion Session.  That being said, if your architecture means that you have to have detached objects this series should be enough to give you a basic grounding the concepts of object state, and how to manage it.

If you want to learn more about managing Hibernate Object States (and there is far more to it than I have written here), you can read more about this in the Hibernate documentation, but this should hopefully have given you a decent enough overview to avoid some possible pitfalls when handling persistence with ColdFusion 9's ORM integration.

Speaking at MAX this year - ColdFusion for Java Devlopers

This year it is going to be my absolute pleasure to be attending and presenting for the first time ever at the Adobe MAX conference.

My presentation is entitled ColdFusion For Java Developers and is scheduled for Wednesday, 5:00pm.

Primarily aimed at Java developers, it is going to cover a myriad of ways that you can integrate your already existing Java code base into a ColdFusion application, and also get your Java model talking seamlessly to your ColdFusion code base.

The official synopsis is:

Ever since ColdFusion was re-implemented as a J2EE application, the benefits of combining Java and ColdFusion application development have been easy to see, and widely used across the ColdFusion landscape.

This talk will look at some of the ways we can already take advantage of common Java libraries in ColdFusion, and enable Java developers to leverage the libraries and frameworks that they are already using. We will also be looking at how Java developers can seamlessly leverage the dynamic scripting language of ColdFusion, within their Java code, to easily enable them to take advantage of some of the RAD features that come bundled with ColdFusion.

That being said, if you are a ColdFusion developer who likes to also work with Java, you may wish to come along, as there will be several techniques demonstrated that will be provided by the forthcoming JavaLoader 1.0 release that should (hopefully) interest you greatly.

I look forward to seeing you all at MAX, and also at the ColdFusion Unconference!

Updated Sample Code for Introduction to CF9 ORM DevNet Article

My apologies if this is a little belated, but here is an update to the sample code that was posted with my DevNet article Introducing ORM in Adobe ColdFusion 9 beta.

Unfortunately several things changed in CF9 between the time that I wrote the article and when the public beta came out.

The major differences between the sample on Adobe.com and this one are:

• The datatype attribute on cfproperty was changed to ormtype.
• Disable Implicit UDF Registration is now turned on by default, so any implicit setter/getter inside a CFC has to be prefixed by 'this.' for them to function.

I will endeavour to keep this download up to date as new versions of ColdFusion 9 are release.

coldfusion9_orm_sample.zip

 

ColdFusion 9 ORM - More on Flushing Hibernate Sessions

Hopefully with my previous article, I've got you understanding how Hibernate Sessions work behind the scenes of ColdFusion.  However, there is one statement I made that requires further clarification before we go any further.

I wrote:
"This means that changes to your objects will also not be persisted to your database, until the end of your ColdFusion request, as that is when the Hibernate Session is closed."

Technically this isn't exactly true, but it was a concept that confused me a lot when first starting with Hibernate, so I wanted to get people thinking in the right direction without complicating things too much.

The Problem

For example, a situation like this made me scratch my head for a long time when I first started working with Hibernate:

We have 5 Musicians in our database, and we want to delete one, and then re-list all of them again.

<cfdump var="#ormExecuteQuery('from Musician')#" label="query">

<p>We are now deleting!</p>
<cfset musician = entityLoad("Musician", 3, true)>
<cfset EntityDelete(musician)>

<cfdump var="#ormExecuteQuery('from Musician')#" label="query">

And we would see a result like:

Tom, Jerry, Ben, Bob, Richard

We are now deleting!

Tom, Jerry, Ben, Bob, Richard

This shows me exactly the same data we before and after my EntityDelete().  Wait... what? Didn't I delete Musician Number 3?

The fact of the matter is, yes, we deleted Musician #3, except since the Hibernate Session hasn't been flushed yet, the data hasn't been persisted to the database.  Therefore, when we run out HQL query, we see all the Musicians!

Hibernate Session Flushing

Before we go directly into how to solve this problem, what does the Hibernate documentation say about when Session Flushing actually occurs?

This process, called flush, occurs by default at the following points: So what does that actually mean in terms of ColdFusion?

1. Before some query executions - So at some arbitrary points during the Hibernate Session life cycle it may flush.  Obviously not something we can rely upon.
2. At the end of a Transaction. So if we our code in a <cftransaction> block, it should flush at the end of that transaction, and therefore the changes to our objects will be persisted in the database.
   
3. When we call ORMFlush(), or at the end of a Session when it is called implicitly.

Therefore, if we wrap the relevant code in or Transaction, like so:

<cfdump var="#ormExecuteQuery('from Musician')#" label="query">

<cftransaction>
<p>We are now deleting!</p>
<cfset musician = entityLoad("Musician", 3, true)>
<cfset EntityDelete(musician)>

</cftransaction>
<!--- Session should be flushed now --->

<cfdump var="#ormExecuteQuery('from Musician')#" label="query">


We should get a result of:

Tom, Jerry, Ben, Bob, Richard

We are now deleting!

Tom, Jerry, Bob, Richard

Alternatively, we could also do:

<cfdump var="#ormExecuteQuery('from Musician')#" label="query">

<p>We are now deleting!</p>
<cfset musician = entityLoad("Musician", 3, true)>

<cfset ORMFlush()>
<!--- Session should be flushed now --->

<cfdump var="#ormExecuteQuery('from Musician')#" label="query">


And we would also see the same results.

So as you can see it is not exactly true that your object data will only get persisted at the end of you request, as you actually have a lot of control over exactly when the Session gets flushed.

It is important to note that 9/10 times you probably won't care when the Session gets flushed and the changes to your objects actually get persisted in the database.  However, there will be instances in which you will care, and your code depends upon having your data persisted in your database.  You now have the tools to manage your persistence life cycle and know what is going to happen when.

ColdFusion 9 ORM - Explaining Hibernate Sessions

Now that ColdFusion 9 is in public beta, I wanted to write some articles explaining how Hibernate is actually working under the hood of the nice ORM integration we now have.  Like all powerful tools, they can do a great many things - but only if you really understand how they work.  Otherwise, they are potential for disaster if you don't know what you are doing.

Hibernate Sessions

The first thing we need to cover is the concept of Hibernate Sessions, which has been nicely hidden away from ColdFusion developers by the Adobe Engineering team, but is still something that you need to really understand to be able to leverage Hibernate in CF9 properly. (At least IMHO).

First things first - don't confuse this with ColdFusion Sessions, or any sort of browser session.  Hibernate is built as a generic solution to ORM, so it has no specific ties to web state. A Hibernate Session is a lightweight object that is used to delineate when Hibernate is meant to start working, and when it is meant to stop, which is often referred to as a unit of work. This may span several transactions and/or INSERT, UPDATE, DELETE and SELECT statements as the Session gets used.

This is very much like the start and stop of a conversation, we say hello at the beginning, and say goodbye at the end, and whatever we need to discuss goes on in between, except we just tell the Session to open() and close(), rather than "hello" and "goodbye".

Actual Hibernate Java code would look something like this:

//open the session from the SessionFactory (which is where sessions come from)
Session session = sessionFactory.openSession();

//get fred, our caveman
Caveman fred = session.get("Caveman", 2);

//change his age to 32
fred.age(32);

//close the session, which will update fred.
session.close();

I'm not going to get into where the SessionFactory comes from, as all you really need to know is: it's where Hibernate Sessions come from.

So what we are doing here is:

1. opening a Session, i.e. we tell Hibernate 'Hi', which starts our conversation.
2. Tell Hibernate to retrieve our Caveman fred, through our session.
   
3. We change the age of fred to 32.
   
4. We close our session, and say 'GoodBye' to Hibernate for now.

There are several things that happen here that are worth noting at this point, even in this relatively simple piece of code.

The first is, by doing session.get("Caveman", 2), we have effectively told our Session to track this object, and make note of any changes that happen to it. 

We have also cached a copy of fred in the Session itself, so that if we were to attempt to retrieve fred again, we would get the same copy.  This is both for performance, and also so that the Hibernate Session only has to deal with one object that represents the data behind fred, which will be a fairly important concept as we continue in this article series.

Since our Session is tracking fred, any change we make to fred will be persisted to the database when we close our Session.  In that way, Hibernate is quite transparent in the way it implements persistence.

It should also be noted at this point: Unless you specify otherwise, Hibernate will only run INSERT, UPDATE and DELETE when the session is closed, generally as a batch.  This is so that, for example, multiple changes happen to fred during the length of our Session, there only needs to be one UPDATE statement when we are finished.  This is an important thing to note, as it is possible to get confused as to why your changes to your objects aren't appearing in your database during your Session, but do appear afterwards. 

Hibernate Sessions and Web Applications

In web applications, it is usual to manage Hibernate Sessions by opening one up at the beginning of a HTTP request, and then closing at the end of the request.  The length of a single HTTP request is a good size to carry on a nice conversation with Hibernate.

Strangely enough, this is exactly what ColdFusion is doing for you behind the scenes.  It starts a Hibernate Session when your request starts, and ties it to that particular request, and then closes it at the end of the request.  (It is quite likely that the Session actually only gets created when first requested, but for the sake of argument it is easier to explain it as it gets opened at the start of the request)

From there, each of the ORM functions, EntityLoad, EntitySave, EntityDelete, etc, all interact with that Session that exists behind the scenes, for that request.

This means that changes to your objects will also not be persisted to your database, until the end of your ColdFusion request, as that is when the Hibernate Session is closed. In later articles, I'm going to cover some ways this can cause some trouble, and how to work around them.

 

You are actually able to flush the Session, which forces it to persist any changes to the database right then and there, and not wait until the end of the request, which can sometimes be very useful. 
To do this in Java, you could go:

session.flush();

But in ColdFusion you write:

ORMFlush();

UPDATE: You can read more about Session Flushing here, which outlines that there are times in which Hibernate will flush a Session in the middle of Session, however, there is often no guarantee except in specific circumstances.

It's also interesting to note you have direct access to the Hibernate Session if you so desire through ORMGetSession(), which gives you access to that request's Hibernate Session object, so you can interact with it directly.

There is much more to Hibernate Sessions and how they relate to the objects that they manage, but this will give us a good start to build upon for now.

You can read more about ColdFusion and Hibernate Sessions in the documentation Hibernate Session Management.

Installing ColdFusion Builder Beta on Linux

UPDATE (21 October 2009): This will no longer work with Beta 2 of ColdFusion builder. If you are looking for a more up to date technique for installing ColdFusion Builder on Linux, please see this post .

---

So I’ve managed to hack my way to getting Bolt installed on Linux, and it wasn’t quite as painful as I thought it was going to be.  It is essentially a pure plug-in install, but we have to jump though a few hoops to get the plug-in itself.

I would suggest starting with a clean installation of Eclipse 3.4.2, with a clean workspace, just to make sure there are no major issues.

Here are the steps you need to reproduce:

• Download ColdFusion Builder for Windows. I used 32 bit, but I don't think it matters.
• in the terminal run: unzip cfbuilder_{your version}.exe, to extract all the content.
  (Update 16/09/09, as Universal Extractor isn't actually needed, see comments)
• Install Universal Extractor - http://legroom.net/software/uniextract
  (I installed under CrossOver office, and it worked a treat, should work under Wine)
• Extract the data from bolt.exe (I extracted to /tmp/bolt), using Universal Extractor
• Extract /tmp/bolt/InstallerData/Disk1/InstData/Resource1.zip, (I extracted to /tmp/Resource1/)
  
• Under /tmp/Resource1/Z_/dist/installer you will find ’installerdist_zg_ia_sf.jar’
• Unzip this .jar file, you will find the /plugins and /features directories you need for a plugin install on Eclipse.
  
• Extract those 2 directories into your Eclipse installation.
  
• If you want the CF Builder Extension Samples, you can find them inside /tmp/Resource1/Z_/installer as ’samples_zg_ia_sf.jar’.  Open up that archive and there they are!
• Fire up Eclipse, and you should now find you have a ColdFusion perspective!
  

So far, there is only 1 annoying bug I’ve found. 

When using CTRL+J to insert a snippet, it inserts perfectly, however, I find I have to click outside of Eclipse, and then back into Eclipse with my mouse before I can edit again (very weird, I know).  It's annoying, but I can work around it.

Hopefully we can provide enough free testing for ColdFusion Beta on Linux, and prove we have a large enough user base, that we can get supported on Linux.

Make sure any bugs you run into are reported to the ColdFusion Builder Bug Tracker page, so that Adobe is aware of them.

ColdFusion 9 Beta Drops, and so does my Devnet ORM Article!

As I'm sure you have all noticed, ColdFusion 9 Public Beta is now available for download.

I am really excited about this release, and think it is going to change the way a lot of people are going to be developing applications going forward.

Some of my favourite new features are:

• Hibernate ORM
  As we all  well know, I have a special place in my heart of Object Relational Mapping, and the inclusion of Hibernate in ColdFusion gives me some lovely goosebumps.  I've worked with Hibernate before, and it really is a top-notch piece of software, and a great ORM to work with.  I can also honestly say that the engineers at Adobe have done an excellent job of providing it to ColdFusion developers in a way that (a) is quite easy for new users to pick up and use and (b) exposes much of the internals of Hibernate to those who are more experienced, and want to do some more complicated things.
  
  I wrote an article for Adobe Devnet, called Introducing ORM in Adobe ColdFusion 9 Beta, which I think is a nice introduction to the basics of ORM, and takes you through some simple steps of using Hibernate in Java without getting too complicated.
  
  Over the next few weeks I plan on writing several more blog posts outlining Hibernate within the ColdFusion context, and giving people more of an idea of what is going on under the hood so they can avoid some 'gotchas' I think people will run into when starting to play with Hibernate.
  

• Language Enhancements
  I am really enjoying writing so much more of my application in CFScript.  Coming originally from a Java background, CFScript is a much more natural fit for the way I like to write code, so I am very excited to be able to do so much more of my development using CFScript, rather than being forced to cut between CFScript and CFTags.
  
  Oh yeah, and let's not forget things like implicit getters and setters, the new and import keywords, and nested transactions (finally!).  So many good things!
  
  
• ColdFusion Builder
  I could go into each and every part of ColdFusion Builder, for which there is a fair amount, but overall I think this is an amazing release for what is essentially a 1.0 IDE.
  
  My favourite part of CF Builder is quite likely just the code assistance in scripts and tags.  I have a ridiculous ability to misspell/miss-type 'arguments' on a regular basis. Now I just type 'arg', hit ctrl+space, and it enters it for me.  Aaaah, no more misspellings !
  

So if you haven't already, grab a copy of ColdFusion 9 Beta, and ColdFusion Builder Beta, and enjoy!

Melbourne Coldfusion 9 and FLEX 4 Usergroup Tour

I just wanted to make sure that everyone was aware of the Melbourne leg of the ColdFusion 9 and Flex 4 Usergroup Tour, on June 17th.

Adobe ColdFusion 9

 

ColdSpring News, CFConversations RoundTable and other cf.Objective() tidbits

While I am recovering from the Australian WebDU conference, a few days before that started I got off a plane after the end of the wonderful cf.Objective() conference.

I have to say, this year's cfObjective() was the best organised out of all the years I have been to.  As per usual, the content was stellar, the hotel was lovely, and it was an absolute pleasure to catch up with everyone at the conference.  I have to give a big 'congratulations' to Jared, Steven, Jim and the rest of the cf.Objective() crew for putting together such a smooth and professional conference.

I had the pleasure of doing two sessions, Rapid OO Development with ColdFusion Frameworks, which covered a variety of techniques on how to increase your development speed when building OO models, and I was very happy to see that it seemed to have been very well received.  I had one attendee let me know that 'Now I know why I'm using ColdSpring! I was using it before, but now I know why', which is an amazing thing to hear as a presenter, that you've managed to create an 'Aha!' moment for someone.

I also did my Introduction to Building Applications with Transfer ORM, which was a repeat of the session that I did last year.  Unfortunately Ray Camden couldn't make it to do his Transfer session, so I was called in at the last minute to take his place.

The big news that we announced at cf.Objective(), is that I will now be the lead developer on the ColdSpring project.  Since Chris Scott's major focus these days is the Swiz Flex framework, he decided it was time to pass on the reigns, and since I tend to talk to him regularly about Cold/Spring, have contributed code to ColdSpring , and know about running an Open Source project, he seemed to think I would be a good fit.  I'm pretty excited about the opportunity, and have discussed some great ideas with theColdSpring development group, of which Chris is going to stay on as lead architect.  I expect we will start off by building the infrastructure around the project, e.g. a centralised wiki, ticket tracker etc, and then move on to some more interesting items.

The obvious question there is, of course, what does this mean for Transfer? (I think I need to start writing down how many times I've been asked if it's 'Dead'.  Does anyone actually expect a 'yes' for an answer?), and quite frankly, I don't see this impacting on Transfer much at all, simply because this is going to be code that I would have probably ended up writing on ColdSpring anyway, but it is now a more formalised relationship.  When I run into a feature or a bug on an Open Source project, that I want to be implemented, my first natural reaction is to start looking into the code, and writing the feature.  This was first exemplified by my contribution toColdSpring of annotation based pointcuts.  There are several aspects of ColdSpring I wanted to improve on, so it was just a natural reaction for me to end up writing code for it.

As stated, the content at cf.Objective() was brilliant as per usual, with my own personal highlights being, Advanced ColdFusion Server Administration (Adam Lehman), Advanced ColdFusion 9 ORM (Terry Ryan) and ColdFusion Portlets (Adam Haskell).

Thinking about the content, I have a little confession to make, that I realised on the way back from cf.Objective() this year.  I have a tendency to go to the wrong sessions when at a conference. This may sound like a weird thing, but I realised the last few years I tend to go to sessions that I already know a lot about, just to see if they say something a little bit extra that I can add to my knowledge base.  Quite often I end up walking out feeling like I haven't added much to my repertoire.  Really what I should be doing is going (mostly) to sessions in which I know absolutely nothing about, which means I actually get the best return on the my investment in the conference.  While it may not be specifically applicable to what I'm currently doing, at the very least it will inspire me to do some interesting new things, and may give me some knowledge that I can then apply at some point in the future.  This is a philosophy I plan on applying to all future conferences that I attend.

Finally, I also had the opportunity to be part of a CFConversations round-table on the second night of the conference.  Brian Meloche, Andy Powell, Andy Matthews and I had a really good chat about the conference in general, our thoughts on some of Adobe's upcoming products, various other topics relating to ColdFusion.  It was lots of fun to do, and you can download and/or read more about it here.

Again, thanks to all the cf.Objective() crew, and look forward to seeing many of you again at cf.Objective(ANZ).

ColdFusion & Flex Data Transformations with Conduit Filters

Previously I discuss a simple mechanism in Conduit to enable you to apply data transformations on outgoing data from ColdFusion to Flex, using a simple inheritance strategy, to overwrite how the CFC=>Flex VO object translation occurred.

The only issue there is, if you need to be able to do different transformations, you end up having to combine separate code-bases into a single CFDeserialiser or CFSerialiser , which is not very portable, or decoupled.

To solve this problem, Conduit has filters that can be applied at different points in the AMF communication life cycle, and manipulate the data that is being passed through.

So, if we take the example we looked at previously, where we reversed every simple value that was travelling from ColdFusion to Flex, we can convert this into a simple filter, which is much easier to apply, and can be combined with other filters to do fairly complex data manipulation.

An example ReverseFilter looks like this:

<cfcomponent hint="filter that reverses all strings" output="false">

<cffunction name="init" hint="Constructor" access="public" returntype="ReverseFilter" output="false">
    <cfargument name="args" hint="the argument ConfigMap" type="struct" required="Yes">
    <cfscript>
        return this;
    </cfscript>
</cffunction>

<cffunction name="doFilter" hint="does the filtering - reverses strings" access="public" returntype="void" output="false">
    <cfargument name="filterData" hint="the data for the filter" type="struct" required="Yes">
    <cfargument name="filterChain" hint="the filter chain" type="conduit.core.filter.FilterChain" required="Yes">

    <cfscript>
        >//we know there will be a 'result', in the after filter
        if(isSimplevalue(arguments.filterData.result))
        {
            arguments.filterData.result = Reverse(arguments.filterData.result);
        }

        >//push on to the next filter
        arguments.filterChain.next();
    </cfscript>
</cffunction>

</cfcomponent>

The doFilter() method is the method that manipulates the incoming data, in this case, looking at the 'result' argument that is being passed in, and if it's a simple value, reversing it.

The Filter is then passed on to any subsequent filters, by calling the next() method on the filterChain.  If we didn't want filtering to continue, we could simply skip that step.

We then configure this ReverseFilter against the CFSerialiser, to convert outgoing data that is going to Flex, like so:

<destination id="Conduit">
     <channels>
        <channel ref="my-cfamf" />
     </channels>
     <adapter ref="conduit" />
     <properties>
         <source>*</source>
         <cfcs>
             <!--- cfc config --->
         </cfcs>         
         <filters>
            <!-- This is an example filter that reverses strings -->        
            <filter>
                <path>conduit.core.filter.example.ReverseFilter</path>
                <apply-after>serialiser</apply-after>
             </filter>
        </filters>
    </properties>
</destination>

The 'apply-after' section, tells Conduit to fire the ReverseFilter after the processing of the CFSerialiser, rather than before, although in this case, it won't make that much difference.

This is just a simple example for the sort of things that can be done with Conduit Filters, but it should give you a good idea on how with a few simple filters, you can drastically change the way data is sent to and from Flex and ColdFusion.

If you want to read more about Conduit, please have a look at the wiki, and daily builds can be downloaded from the google group.