Bob's Blog - ColdFusion Tidbits - ColdFusion

CFUnited is Almost Here - Learn about Validations and ORM

Mon, 19 Jul 2010 09:47:00 -0400

As I'm sure many of you are aware, the final CFUnited will be starting in a little over a week. Although I did attend a couple of CFUN's in the past (when they were a one-day event), this will be my first CFUnited, so I'm pretty excited about it. It will be great to meet even more people than I usually do at other conferences, such as cf.Objective() and NCDevCon, and I wanted to give a final plug to my sessions, as I think they will be of interest to a lot of developers. As well, I've made some last minute changes to both sessions to cover some new material.

What Your Mother Never Told You About CF9 ORM

The ColdFusion team at Adobe have done an outstanding job with ColdFusion ORM, which now provides ColdFusion developers with access to Hibernate, an enterprise-ready, open source, industry-standard Java ORM. The documentation on how to use CF ORM in the ColdFusion docs is also quite good, providing most of what you need to know to make use of the features. The problem, however, is that Hibernate is a pretty complex tool, and in order to use CF ORM successfully you really need to understand certain things about Hibernate. This session is designed to teach you some of those things - it will cover material that is not included in the ColdFusion documentation, but that is essential to understand when working with the ORM.

Topics covered will include Hibernate Session Management, Understanding Object States, Working with Detached Objects, Concurrency and Using a Base Persistent Object. We'll also be looking at the new Transaction Management model in the recently released ColdFusion 9.0.1. If you plan on working with CF ORM and are not already familiar with these concepts I think you'll really benefit from this session. It is, however, an advanced session, so if you are totally unfamiliar with CF ORM you may find it a bit confusing.

The session is scheduled for 5:30pm (ouch!) on Wednesday, July 28th.

Automagic Validations for ColdFusion Objects

This session will provide an overview of, as well as a detailed how-to about a Validation framework for ColdFusion. The title is a slight misnomer, as, although the framework was originally written to work inside an object-oriented application, and remains an ideal solution for that, it has recently been enhanced to work with simple ColdFusion structures as well. This means that anyone who is looking for a better way of addressing their validation requirements, both on the client side and on the server side, can now benefit from the framework, even if they are not using objects.

The main benefit of the framework is that it will automatically generate all of your client-side and server-side validations for you, from a simple set of metadata. This frees you from the drudgery of writing similar validation code over and over again, and also eliminates the possibility of adding bugs into your application via your validation code. The framework, called ValidateThis, is being actively developed by myself and a number of other contributors, so not only is it extremely functional and flexible right now, but new features are being added continually. If you are interested in finding out more about it, including exactly how to implement it in a new or existing application (and it's dead easy), I encourage you to attend my session. It will be held at 3:15pm on Friday, July 30th, and is being repeated at 2:45pm on Saturday, July 31st.

I hope to see you at one, or both, of my sessions. If we haven't met before please come by and say hi.

ColdFusion 9.0.1 Now Available - With ORM Goodies

Tue, 13 Jul 2010 11:48:00 -0400

ColdFusion 9.0.1 is now available for download at http://www.adobe.com/go/getcf901, and, in addition to fixing a number of issues with ColdFusion 9.0, it's packed full of goodies as well. The details of all the new features can be found in the New Feature Notes, and the bug fixes and outstanding items can be found in the Release Notes. I think my favourite single new feature is the ability to do a for - in loop with an array, as looping through an array using script has always been a pain. I'm also very happy with some of the improvements to ORM. Here's a high-level summary of the new features, followed by some details on the ORM changes:

Language enhancements - including for-in loops for arrays.
New script functions implemented as CFCs - including dbinfo, imap, pop, ldap, and feed.
Caching enhancements - including the ability to get a handle on the ehCache session.
Support for IIS 7
ColdFusion Ajax enhancements - including updates cfmap, cfgrid, file uploading and JavaScript functions.
ORM enhancements - more details below.
Amazon S3 support - the ability to use Amazon S3 storage with most tags and functions that use a file or directory as input or output.
Various other enhancements covering areas such as Spreadsheets, AIR Integration, Flash Remoting, Blaze DS, Solr, Logging, Server Monitoring, and more.

ORM Enhancements

Here's a summary of the ORM enhancements in ColdFusion 9.0.1, followed by some details about each one:

Support for Multiple Datasources
Transaction Management Improvements
skipCFCWithError Flag in ormSettings
mappedSuperClass Attribute for Components
Use EntityNew to Populate a New Entity
Support for HQL in cfquery

[More]

Send Push Notifications to an iPhone from ColdFusion

Mon, 21 Jun 2010 09:41:00 -0400

Notifo is a relatively new service which allows you to send push notifications to mobile clients via a REST interface. Currently notifications can only be sent to the iPhone, but they plan to add support for Android and Blackberry in the future. Because it is based on a REST API, it's very easy to interact with from a ColdFusion application, and I wanted to give it a try, so I whipped up a quick API wrapper for it. It all seems to work extraordinarily well, and is quite cool.

CFNotifo is Born

I found out about Notifo from the GitHub blog, which describes a Notifo service hook that was just added. This service hook allows you to receive push notifications on your iPhone any time someone commits to your Git repo. Of course I had to try this right away, and was duly impressed. The next step was to write some CFML that interacts with the API, so, as I mentioned above, I decided to create a simple API wrapper to make it even easier for others to do the same. In a matter of minutes I was able to create a single cfc which implements all of the current API. This wasn't that challenging as there are only two API methods right now, subscribe_user and send_notification, but as Notifo adds more, I will follow suit.

How Does Notifo Work

Paul Stamatiou, co-founder of Notifo, wrote up a detailed post about Notifo on his blog, which is well worth reading. If you don't feel like following the link, here are the highlights:

Allows you to send push notifications to a mobile client from a server.
Currently iPhone is supported, via an app available in the app store. Android is up next, with other smartphones to be added in the future.
To subscribe to services you need a Notifo account, which can be set up via the Notifo site, or via the iPhone app.
To receive notifications you need to have the iPhone app installed.
Once you've subscribed to a service you can set various options for it via a web interface, including what type of notifications you want to receive (normal, silent and stealth), and you can unsubscribe, block and report spam on a service.
You can also set some global options for notifications, such as silent hours, during which notifications will be sent silently.

[More]

My Interview on WebDevRadio

Thu, 17 Jun 2010 10:49:00 -0400

I had the honour and pleasure of being interviewed by Michael Kimsal for his WebDevRadio podcast a few weeks ago. The episode was published last week and is now available for listening and/or downloading from the podcast website, as well as via iTunes.

For those of you that don't know Michael, you're missing out. I met him at NCDevCon and found him to be an extremely pleasant, funny and smart individual. I enjoyed my chats with him at the conference, and really enjoyed discussing all sorts of topics with him for the podcast, including, but not limited to, how I came to develop using ColdFusion, contributing to open source projects, test-driven development and unit testing in general, and object-relational mapping (ORM) in ColdFusion. I also really appreciated the opportunity to have my voice heard outside of the ColdFusion community.

ValidateThis Futures from cf.Objective()

Wed, 28 Apr 2010 16:45:00 -0400

I returned from cf.Objective() a few days ago and have been catching up on all sorts of things. I hope to post a review/discussion of the conference as a whole soon, but for now I just want to touch on some things that came up around ValidateThis.

I gave a presentation entitled Easy and Flexible Validations for Objects during which I described what ValidateThis is, and showed how easy it is to work with. I demonstrated that you can add client-side validations to a form with a single line of code, and can perform server-side validations with just a few lines. I also discussed the different types of validation scenarios that VT is designed to address. There were some questions and suggestions which have prompted me to think of future enhancements to the framework, so I wanted to discuss them here. [More]

I'll Be Presenting at NCDevcon in May

Tue, 27 Apr 2010 10:12:00 -0400

I'm tickled pink to announce that I will be presenting a couple of sessions at the upcoming NCDevCon, dubbed North Carolina's Premier Web Conference, which is being held in beautiful Raleigh, North Carolina on May 22nd and 23rd. As I discussed in a previous post NCDevCon is being organized by the Triangle Area ColdFusion User's Group and is a sequel to the hugely successful and wildly talked about CFinNC.

I will be presenting two sessions:

Getting Started with ColdFusion ORM
Creating a Twitter / Google Maps Mashup with CF and Open Source Tools

The first session is one that I have presented before, but ColdFusion ORM is an important topic and therefore the committee considered it worth presenting again. The second session will be a fun one. In it I will demonstrate how I used a number of freely available open source tools to generate a Google Map showing the locations of all of my Twitter friends. This is a project that I built some time ago, and is currently available via my site. I'll be making some updates to it prior to the conference and my hope is that the session will illustrate two points:

There are pre-existing ColdFusion open source projects that can be used to fulfill many of your application's requirements.
It's very easy to create something cool using ColdFusion.

The conference itself is still chock full of ColdFusion, Flex and AIR goodness, but also includes a healthy dose of JavaScript, CSS and other web development topics. The schedule with a full list of sessions has been published, and it's top notch. I'm particularly pleased to see some folks whom I met last year presenting this year, including Daria Norris and Jim Leether. There will also be a number of hands-on ColdFusion sessions for beginners, so if you know someone who would benefit from a bit of a ColdFusion kick-start, send them down North Carolina way.

Registration is open, and, just like last year's CFinNC, it's absolutely free. I hope to see many of you there.

Managing Bi-directional Relationships in ColdFusion ORM - Array-based Collections Follow-up

Fri, 02 Apr 2010 09:01:00 -0400

Barney Boisvert made a comment on my last post on this topic, suggesting that a nice way to reduce the amount of code one has to write, and to boost performance, would be to have one side in a bi-directional relationship simply delegate to the other side. This way you are only writing the code to do the work in one object, and it also reduces the number of hasX() calls.

I changed my code to try this technique out, and I quite like it. Because the code is slightly different I figured I might as well write about it here, to keep my posts on this topic up to date. [More]

Managing Bi-directional Relationships in ColdFusion ORM - Array-based Collections

Mon, 29 Mar 2010 06:00:00 -0400

It's important to know that when you have a bi-directional relationship you should set the relationship on both sides when setting one side. There have been a number of discussions about this on the cf-orm-dev google group, including this one in which Barney Boisvert provides a very good explanation of why this is important. Brian Kotek has also written two articles on the subject in the past. If you're not already familiar with this topic I suggest you check out those links.

The general recommendation for addressing this requirement is to override the methods in your objects that set one side of the relationship (e.g., setX(), addX() and removeX()) so that they'll set both sides, rather than just the side of the object that was invoked. While doing some testing of the new CF9 ORM adapter for Model-Glue along with the new scaffolding mechanism that we're developing I needed to address this issue for a many-to-many bi-directional relationship. I found that there were a few wrinkles that made the task not quite as straightforward as I has originally imagined, so I figured I should share what I came up with. [More]

The This Week in ColdFusion Podcast is Back!

Fri, 26 Mar 2010 09:58:00 -0400

That's right, the mighty fine folks who bring you the This Week in ColdFusion podcast have released a new episode. After what seems like an interminable hiatus, the boys are back and guess what? I'm on it too! I was interviewed about the upcoming cf.Objective() conference and the incredible pre-conference training that will be available. I also discussed the Pecha Kucha BOF that I am organizing.

After my cameo Brian and Mike had a lively and informative chat about design patterns, which I stuck my nose into from time to time. It was great fun and I encourage you to give it a listen. It's available via iTunes, and can also be listened to or downloaded directly from the show page.

Connecting to Derby Databases on OS X using SQuirreLSQL

Tue, 23 Mar 2010 04:27:00 -0400

Today I had a need to connect to and mess around with one of the Derby databases that ships with ColdFusion. I don't have RDS set up, plus I'm fairly certain that RDS does not allow you to modify data in tables, so I needed a solution. I had no idea where to start, so of course I simply Googled "derby database client tools" and one of the first links I saw was an article entitled Using SQuirreL SQL Client with Derby, by Susan Cline. I recalled that SQuirreLSQL is a client that runs on OS X, so I clicked.

Boy was I glad that I did. The article covers just about everything you need to know to get up and running with Derby on OS X, and a whole lot more, and I highly recommend reading it. If you don't feel like seeing the details, I've included a simple step-by-step guide below:

Install SQuirreLSQL
1. Download SQuirreLSQL from the downloads page. I clicked the link labelled Install jars (and source) of SQuirreL 3.1 for MacOS X.
2. Open up a terminal window and change to the folder where the downloaded jar file is located.
3. Run the install package by typing the following command:
```
java -jar squirrel-sql-3.1-MacOSX-install.jar
```
  where squirrel-sql-3.1-MacOSX-install.jar is the name of the file you downloaded.
4. Tell the installer where to put the app file (I chose /Applications/SQuirreLSQL.app), and choose the plugins to install. I chose a whole bunch of plugins as I wanted to see what they do, but make sure you choose the Derby plugin.
Configure SQuirreLSQL to Use Derby
1. Start SQuirreLSQL by running the app file that you just installed.
2. Click the Drivers tab.
3. You should see Apache Derby Embedded as one of the drivers listed. If it has a blue check mark beside it then SQuirreLSQL is ready to access Derby databases, and you can continue with Configuring SQuirreLSQL to Use Your Database, below. On the other hand, if, like me, you see a red x beside it, then you need to continue with the following steps.
4. Select Apache Derby Embedded in the list and click the pencil icon, which allows you to edit the driver.
5. Click the Extra Class Path tab and then click the Add button.
6. Browse to a folder that contains the derby.jar file. It should be located in the /lib folder of your ColdFusion server. For example, on my machine it's in /Developer/CF9/servers/cfusion/cfusion-ear/cfusion-war/WEB-INF/cfusion/lib. Select the derby.jar file and click the Choose button.
7. Now click the List Drivers button which should populate the Class Name select box.
8. Select org.apache.derby.jdbc.EmbeddedDriver from the Class Name select box, and click the OK button.
9. You should be returned to the main SQuirreLSQL window and see the message
```
Driver class org.apache.derby.jdbc.EmbeddedDriver successfully registered for driver definition: Apache Derby Embedded
```
  at the bottom of the screen. The Apache Derby Embedded driver should now have a blue check mark beside it.
Configuring SQuirreLSQL to Use Your Database
1. Click on the Aliases tab.
2. Click the blue + symbol to add an alias.
3. Give your alias a name. I chose the name of the database, so I put cfartgallery into the Name text box.
4. Choose Apache Derby Embedded from the Driver select box.
5. In the URL text box, replace the text <database> with the location of your database. I went to the datasource information in the ColdFusion Administrator and copied the contents of the Database Folder text box from there. The value I used was
```
/Developer/CF9/servers/cfusion/cfusion-ear/cfusion-war/WEB-INF/cfusion/db/artgallery
```
6. Check the Auto logon check box.
7. Click the Test button. You should see a dialog pop up saying "Connection successful".
8. Click the OK button. You should now be able to connect to the cfartgallery database!

Once again I just want to point out that all of this is covered by Susan Cline in her excellent guide. If by any chance she ever reads this, I'd like to thank her for this wonderful and well written resource.

Coming to cf.Objective()? What Interests You?

Tue, 16 Mar 2010 11:40:00 -0400

The folks organizing cf.Objective() are in the process of finalizing the BOF sessions and are looking for feedback from you!

In case you're unfamiliar with the term, BOF stands for Birds of a Feather and it's an informal session in which the attendees get a chance to chat about a topic with other developers who have similar interests. It's a great chance to get a bit more interactive - you get to participate rather than just sit and watch.

I suggested that during one of the BOF sessions we do a series of Pecha Kucha presentations, which are similar to Ignite presentations, and my suggestion was graciously accepted by the committee. I blogged about this session previously and am still looking for volunteers to present, so if you're interested in that please mosey on over to that blog post and comment.

There are seven remaining BOF slots, and Sean Corfield has blogged about the other topics that have been suggested thus far. Here's a summary:

Open BlueDragon
Security
Extending Mura
Home Brewed ColdFusion Monitoring
Being Agile
Guitar Hero
ColdFusion 10
Mobile Development
SciFi
Photography
Poetry Slam
Open Source Project Discussion
Test-Driven Development (TDD)

Decisions will be made in the not-too-distant future, and to help you vote on topics and make new suggestions a survey has been created. It's a one-question survey that should take no more than about 30 seconds to complete, so if you'll be attending cf.Objective() please take the time to add your opinion.

I hope to see many of you at cf.Objective() in April!

CFinNC is Dead. Long Live NCDevCon!

Sat, 13 Mar 2010 14:34:00 -0400

In October of last year I had the honour of speaking at CFinNC, a ColdFusion / Flex / AIR conference organized by the Triangle Area ColdFusion User's Group. It was an outstanding conference; well run, with informative sessions on timely topics, which is pretty amazing considering that it was absolutely free.

The mad geniuses behind CFinNC are throwing another conference this year, and this time it's called NCDevCon. It will be held May 22-23, 2010 on the Centennial Campus of NC State University in Raleigh, North Carolina. This year's conference is planning on covering a wide variety of web development and design topics including ColdFusion, Flex and AIR, Javascript and CSS, and, just like last year, it's free as in beer.

Registration is already open, as is a Call For Presentations. I'm hoping to get a chance to speak again this year, but even if I don't I'll be there to partake in the learning and festivities. If it turns out to be anywhere near as good as CFinNC (and I'm sure it will), it will be a conference that you won't want to miss.

Become a ColdFusion ORM Ninja in Just Two Days!

Tue, 09 Mar 2010 11:47:00 -0400

I've mentioned previously that Mark Mandel, the mastermind behind Transfer ORM, JavaLoader, ColdDoc, and now the lead developer of Coldspring, and I have developed an intensive, two-day, hands-on workshop on ColdFusion's new ORM features. We will be delivering that workshop, Developing Applications with ColdFusion 9 Object Relational Mapping, in Minneapolis, MN on April 20-21, 2010 which are the two days immediately preceding the cf.Objective() conference.

Really? I Can Master ColdFusion ORM in Two Days?

You bet you can! This is an extreme hands-on workshop. We won't be lecturing at you, we'll be working with you. For each concept that we cover we'll be writing code together, both the instructor and the students, working towards building a single, working application. Then, once we've done that together, you'll be let loose on your own to practice the concepts again on your very own project, which is yet another application which will be built incrementally using the concepts that you just learned. This means you'll have lots of chances to practice your newfound skills, and, more importantly, to make your own mistakes. You'll either figure out how to fix your mistakes yourself, with the help of one of your fellow students, or with the help one of the two instructors. You'll learn by doing, and what's more, you'll leave the class with lots of examples of working code that you wrote yourself.

This is why we say that we can help you master ColdFusion ORM in just two days. Not only will you be ready to start using it in your next project, but you'll also be in an ideal position to teach it to your fellow developers.

About the Instructors

I've been working with Transfer ORM for a few years, and have been working with ColdFusion's ORM integration since early in the product beta. I've blogged about it extensively, delivered a number of one-hour presentations on the subject and have created and regularly contribute to a Google group (cf-orm-dev) dedicated to discussing some of the more advanced and esoteric topics around ColdFusion's ORM integration.

As for Mark, in addition to creating his own ColdFusion-based ORM (Transfer), he's also worked extensively with Hibernate (the ORM that is integrated into ColdFusion 9) and is considered by many to be the foremost expert in all things ORM in the ColdFusion community. This therefore represents a unique opportunity to learn about this new, exciting and productivity enhancing technology from two people who know it very well, and have real-world experience developing with it.

Do I Have to Be an OO Guru to Attend?

Definitely not! We assume no prior knowledge of ORMs or Object Oriented programming, and the techniques that we teach can be used, if you wish, in a totally procedural application. So you neither need to know OO to join in, nor do you need to learn OO in order to use what you learn in your own work (although we would encourage you to do so). Some experience working with CFCs would be helpful, but we can get you up to speed pretty quickly even if you lack that.

Where is the Workshop Being Held?

As mentioned above, the workshop is running as a pre-conference training session at cf.Objective(), and will take place from April 20 - 21, 2010 at the conference hotel, which is the Hyatt Regency in Minneapolis, MN.

How Much Does it Cost?

We have made the early-bird price into a permanent discount, so although the original price was listed at $1200 for the two days you can now enroll for just $1000.

How Do I Sign Up?

You can register for the training via cf.Objective()'s registration form.

Can Anyone Attend?

Although the workshop is being offered as a cf.Objective() pre-Conference class, you don't have to attend cf.Objective() in order to enroll. So if you've having trouble getting your boss to pony up for a trip to cf.Objective(), perhaps you can convince him or her to at least send you to these two days of invaluable training.

What Topics Will Be Covered?

Here's a summary of the topics that we'll be covering:

Introduction to ORM
Introduction to Hibernate
Configuring ORM
Working with Objects
- Creating an Object
- Retrieving an Object / Lists of Objects
- Updating an Object
- Deleting an Object
- Arrays of Objects vs. Queries
Mapping Objects
- Ids and Properties
- Many-to-One Relationships
- One-to-Many Relationships
- Many-to-Many Relationships
- Formulas
- Collection Mapping
- Inheritance
- Cascade Options
Hibernate Internals
- Hibernate Sessions
- Session Flushing
  - How It Works
  - How to Control It
- Working with Transactions
- Hibernate Object State
  - Transient, Persistent and Detached
  - How Objects Move between States
Lazy Loading
- Overview
- How it Affects SQL
- Dealing with Detached Objects
Concurrency
HQL
- What is HQL?
- Basic Queries
- Criteria / Parameters
- Joins
- Pagination
- Bulk Updates
Application Architecture
- Using a Service Layer with ORM
- Using an Abstract Service
Caching
Event Handling
DDL (Database) Generation

Truly a Unique Opportunity

Although we do have plans to make the course available at other venues in the future, Mark and I live on opposite sides of the planet, and it just so happens that we'll both be attending cf.Objective() this year. It's likely that future classes will feature either Mark or I as instructors, as it's a rare occurrence that we're both in the same place at the same time, so don't miss this unique opportunity.

Looking for More Information?

I think I've covered most of what you need to know about the course in this post, but if you're looking for even more information about it please visit our web site at www.ColdFusionORMTraining.com.

ValidateThis 0.92 - Easier to Extend, More Object Support, and more

Sat, 20 Feb 2010 22:40:00 -0400

I've just released version 0.92 of ValidateThis, my validation framework for ColdFusion objects. I'm very pleased to say that I received a large code contribution from Adam Drew, most of which made it into the framework. I also finally got around to adding John Whish's changes to the bundled ColdBox plugin. Here's a summary of all of the enhancements, followed by the details for each one.

ServerRuleValidators can be located anywhere.
Business objects with an abstract getter are now supported.
New DependentFieldName parameter for conditional client-side validations.
Fix to future-proof ColdBox plugin.
Fixes for Groovy conditional validations.

The latest version can be downloaded from the ValidateThis RIAForge site. Details of the enhancements follow: [More]

Using the Mura FW/1 Connector Plugin

Fri, 19 Feb 2010 15:45:00 -0400

Several months ago Pat Santora of Blue River and I developed a Mura plugin that would allow a developer to take an existing FW/1 application and deploy it within a Mura page. I was interested in this as I saw a need for a lightweight framework that I could use for my plugins, and by coincidence Pat happened to be working on something similar. So we joined forces and the FW/1 Connector Plugin was born.

The plugin was finally released yesterday so I thought it prudent to author a post about how to use the plugin.

Overview

The FW/1 Connector plugin can be used to incorporate an FW/1 application into Mura. Each plugin can be assigned to an individual FW/1 application. As long as each FW/1 application has a unique applicationKey, you can have as many FW/1 applications running inside Mura as you please. [More]