I was very pleased that my CF Dev Week presentation was so well attended and received. I am attaching a PDF of the presentation materials to this post. Once the recording is available, you'll be able to find it at www.adobe.com/devnet/coldfusion/events.html.
I am pleased and honoured to announce that I'll be teaching and speaking at RIA Unleashed in Boston in November. Organized by Brian Rinaldi (one of my heroes in the ColdFusion community), RIA Unleashed is a conference that I have wanted to attend in the past and I think this year's version is going to be stellar. The format is a bit different from other CF conferences that I have attended: it's a two day conference, with day one consisting of half-day hands-on workshops, and day two having standard one-hour sessions across multiple tracks. You can find more information about the half-day workshops and one-hour sessions at the RIA Unleashed site.
The conference runs from November 11-12, 2010, in Boston. You can register for just day one for $150, just day two for $50, or both days for the bargain price of $175, which includes lunch on both days and a party on Thursday night. Brian is also running a contest which will award three lucky winners with a two-day pass to the conference.
I'll be teaching a half-day workshop and presenting a session on, you guessed it, ColdFusion ORM. The day one workshop will be a hands-on introduction to ColdFusion ORM, designed to teach you the basics of working with this powerful new technology. My session on day two is called "What Your Mother Never Told You About ColdFusion ORM", and it covers advanced topics that you won't read about in the ColdFusion documentation. It will be a great follow up for folks who attend the half-day ORM workshop, and will also be valuable to anyone who's looked at ColdFusion ORM already.
I'm really looking forward to attending this conference, and I hope to see some of you there in November.
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 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
- 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.
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
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.
Registration is open, and, just like last year's CFinNC, it's absolutely free. I hope to see many of you there.
Mark Mandel, and I have decided that we're going to give a copy of the book Java Persistence with Hibernate to each and every student at our Developing Applications with ColdFusion 9 Object Relational Mapping workshop, which is running from May 20-21, 2010 in Minneapolis, MN, which also happens to be the two days immediately preceding the cf.Objective() conference.
I've discussed this two-day, hands-on workshop at length in a previous blog post, so I won't repeat myself here, but one of the goals of the course is to teach you what you need to know about Hibernate to be effective with ColdFusion 9's ORM features. Although the Adobe engineering team have done an excellent job of integrating Hibernate into ColdFusion, it is still essential to understand quite a bit about Hibernate to make appropriate use of the features. Hibernate is a complex beast, and although we'll be teaching most of what you'll need to know in the course, it's always helpful to have a reference manual handy.
There is a lot about Hibernate that is not covered in the ColdFusion documentation, and Mark and I both feel that Java Persistence with Hibernate is the best book currently available on the market about Hibernate. We want to arm our students with the tools they'll need to continue their ORM education after the workshop, which is why we've decided to give a copy of the book to each student.
There are still spaces available in the class, so if you'd like to become a ColdFusion ORM ninja in just two days, and get a free copy of the "Hibernate Bible" as well, sign up today.
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.