CounterMarch Systems Blog - ColdFusion

Mach-II is (still) awesome

Thu, 29 Jul 2010 16:21:00 -0400

Mach-II rocks. It is one of the more "mature" surviving ColdFusion application frameworks, and as such doesn't get nearly the amount of buzz that the new (interesting, different, creative, awesome-in-their-own-way) frameworks get. If you're looking at frameworks, I encourage you to take a look at the amazingly capable Mach-II - we've had fantastic success with it!

Things I really, really like about Mach-II:

Backwards compatibility

Take an old (Mach-II 1.1 app, circa 2006) and update the framework to 1.8 (released 2009). Replace the application.cfm file with application.cfc, comment out everything in index.cfm and *boom*...you're done. I can't really assess how challenging it is for the team to maintain backwards compatibility, but I sure do appreciate how simple it is to upgrade. Instant feature add with zero headaches.

Coldspring integration

and in your listeners:

I don't think it gets much easier than that. Instant Coldspring integration for dependency injection (and more), radically simplifying the configuration of all of my listener and model cfcs. Now we've got all the power of Coldspring cleanly available to our Mach-II application.

Faster Fixes

Knowing where to find things is one of the hallmarks of any good framework. Some do it by convention, some by configuration. Mach-II falls into the latter camp but that's perfectly fine by me. Getting back into the mental model of an application months (or years) after deployment is a challenge but by simply cracking open mach-ii.xml I can see what happens where within seconds and bend it to my will. I love this.

Modularity

This wasn't in the framework back in the 1.0 and 1.1 days (when we created some mammoth apps), but by 1.5 (which came out in 2008) the ability to break up large Mach-II applications into separate modules was baked in and oh-so-handy. It's two years later and we've been able to make the easy changes to break those older apps into a collection of modularized sub-apps for much easier maintenance. Perfect example is an extranet: lots of only slightly related apps put under one common umbrella sharing security or UI components. This is easy to implement and support in a well-designed Mach-II application. All of our more recent apps make use of this feature.

The Team

The people who created and have since improved and evolved Mach-II are some of the smartest folks who are or have been involved in the ColdFusion community. Look at this list. Not only have they created something awesome, but they're incredibly responsive on the wiki, development Google group, and framework users Google group. They use this framework at their day jobs so you know that each release has been painstakingly designed, implemented, tested, re-tested, piloted and then released. Plus, they're open to new ideas (even if you personally have no idea how to make them happen!). Code is great, but the people are the best.

The View Loader

This is where some of those "convention-based" concepts have crept in to Mach-II much to the benefit of the users. Back in the "bad old days" your mach-ii.xml file would contain a block that looked sorta like this, except far longer:


	
		
		
		
		
		
		
		
	(and so on)

Each page would have a page-view defined. Someone called shenanigans on it and now we have the PatternViewLoader to replace ALL of it!

So, so simple. Love this line of the config file more than any other.

Better apps, faster.

Take Mach-II off the shelf and use it as your "glue." Add Coldspring to manage your model. Use ColdFusion 9's new Hibernate ORM capabilities to cut the lines of code in your model by a huge factor. Redirect some of the saved time into building a better UI using jQuery, improving your cross-browser capabilities with clean CSS and making your client happier by communicating more frequently. Result: a better app, designed to be maintainable and much more in line with your client's spoken and unspoken expectations. How could any craftsman not feel good about that? Mach-II is a key component to that successful formula for us.

Try Mach-II. Need help? Talk to the team on the list. Build great things.

Mobile Apps for Alumni Relations - Cornell Compass

Tue, 22 Jun 2010 10:10:00 -0400

We recently had the privilege of working with Andrew Gossen in Cornell's office of Alumni Affairs on a sweet little mobile project.

The Cornell Compass web application uses geolocation features exposed through mobile browsers to determine the distance and bearing from where you're standing to the center of Cornell's campus. It's fun! It would be way more fun if the orientation of the device was exposed as well (then we could make the compass dynamically spin in real time).

Once your location is determined you have the opportunity to "Check In" and drop a marker on a map with your name and class year (both optional). The map is visible both on the mobile device and via the website (we do some browser sniffing so the content is device-appropriate). All visitors are encouraged to share the link to the site via Facebook and Twitter.

The Compass app is optimized for iPhone, but is functional on both Blackberry and Android devices as well. The backend (which is trivially simple) is ColdFusion with Microsoft SQL Server. The bulk of the front end work was done using jQuery and a few assistive javascript libraries for doing the bearing calculations.

We're working with Cornell to design the next version of this application with more features that make it useful to Cornellians all over the world looking to deepen their relationships with each other. Interested in learning more? Please drop me an email! We're interested in working with other organizations to enhance the usefulness of the app including integration with alumni online communities and CRM systems.

ColdFusion 9 Security Lockdown Guide

Wed, 26 May 2010 17:06:00 -0400

Adobe published the work of Pete Freitag today - a 35 page guide to secure installation and configuration of ColdFusion. Even if you feel like your ColdFusion server(s) are tightened up, it's always a good idea to take a moment to do a review.

While the guide does not go into detail on building secure applications, Pete's PDF is a step-by-step tutorial that even someone not familiar with ColdFusion administration could follow. Grab the PDF and spend the 15 minutes to check up on all of your servers (including your local development environment) - it's well worth it.

When you're done with that, check out the Security section of the ColdFusion Developer Center on the Adobe Developer Connection for lots of articles on how to write safe and solid code too!

CFSpreadsheet presentation and samples

Fri, 15 Jan 2010 14:20:00 -0400

I'd like to thank Adam Tuttle and the Philadelphia CFUG for inviting me to speak last night on CFSpreadsheet. While the thought of listening to someone talk about spreadsheet generation from an hour would only make a true techie's heart race, I think those who were there got a good overview of what this new functionality can do for them. If anything I hope that I lowered the bar for many in attendance while simultaneously increasing pressure on their bosses to buy those licenses!

My preso focused on the basics (here's the tag, here are the functions) up front and followed up with 6 examples of how these new functions can be used to manage spreadsheet creation and editing no matter how mangled or ugly. If you want the CFSpreadsheet presentation assets and (commented) sample code, feel free to pull this ZIP. I will be updating it this weekend with Derby databases so you can just unzip and run everything. For now, unpack the zip into a folder in your webroot. You may need to comment out the ORM settings in Application.cfc to make it run. Ping me with any questions either here or via twitter (@scrittler).

I also had the opportunity to touch (very lightly) on the new ORM features of ColdFusion 9 during the presentation. One of my demos (not in the zip file) is the start of an app that is intended to replace a spreadsheet with a web app. After 90 minutes of work I had the spreadsheet imported to a db using Hibernate, a quick add/edit form put together and a re-export (since the end users still cling to Excel) of the current db. If I had to write all that SQL it could have easily taken far longer. Finishing the app should be trivial from here, so props to Adobe for putting all the right pieces in the box for me to play with!

It's pretty clear that the whole concept of using an ORM engine is very, very new to most of the ColdFusion world and is definitely holding back adoption. You don't need to know terribly much to use Hibernate with ColdFusion but letting go of having to write SQL is certainly showing to be more difficult than expected. It's a different way of thinking, one that the user group community can definitely help to encourage. The time savings and maintainability improvements alone are well worth starting the trip. I know the Philly CFUG calendar is pretty well packed, but I hope we can put together some talks on this topic (preferably hands on) soon.

Again, thank you to the CFUG for inviting me to speak. I look forward to seeing everyone at the next meeting on Feb. 25!

CFSpreadsheet and Conditional Formatting

Mon, 11 Jan 2010 10:28:00 -0400

CFSpreadsheet pretty much rocks the house when it comes to simplifying the task of creating spreadsheets (Excel and Open Office compatible) from ColdFusion. On Thursday January 14 I'll be giving a talk at the Philadelphia CFUG meeting on this topic, but something I was working on last night has me particularly excited and requires a blog post.

Several of the spreadsheets we currently generate for clients have some degree of pretty formatting associated with them. The way we've typically done it is to export a decorated "source" Excel file in Excel's XML spreadsheet format, chop it up and jack the appropriate data into the document, setting style attributes on the cell tags appropriately based on server-side logic. But what if you wanted to create the spreadsheet such that the conditional logic was built in to the spreadsheet itself? The people that use these spreadsheets like to play with the data and it would be awesome if the conditional formatting (highlight in some color, change font size, whatever you like) would apply to their edited data.

It didn't seem immediately possible using CFSpreadsheet or any of the 37(!) functions exposed in ColdFusion...but then I remembered that this functionality is built on top of Apache POI, so there had to be a way to get down and dirty with the Java internals. It's not hard to get there, but whoa the code to implement conditional formatting is definitely verbose.

What I want to do is set up a conditional formatting rule on the 6th column (F) such that if the value is greater than 10 the background is set to yellow.



	




	


	


    																		"10", 
     																		javacast("null", "")     
 																		) />

Then it's just a matter of inserting the spreadsheet contents as usual.




	select 
			facultyID, pidm, loginID, firstName, lastName, startYear, department, title
	from 
	 		coe_faculty
	order by
			lastName

The end result:

Checking the conditional formatting panel in Excel we see that it's legit and not hard coded.

I'll post more as I dig in and build more complex examples. This is a simple expression, but it should be enough to get you started if you need to do this kind of thing with ColdFusion and a generated spreadsheet!

Presenting at the Philadelphia CFUG

Tue, 15 Dec 2009 17:20:00 -0400

Adam posted the January 2010 meeting announcement to the CFUG website today -- I'll be doing a presentation on the "powerful simplicity" that is CFSpreadsheet (and associated functions) on the 14th at Penn.

I'm especially excited about this topic because of the frequency with which I generally have to work with(against) Excel. Pretty much every project of ours uses Excel as a report output format and we've tried everything from building tabular data in HTML and "faking it" to saving Excel files in XML format and rebuilding on the server side. Both of these options had limitations (the first being stylistic, the second being fragility), so now that ColdFusion has a simple way to build them I'm a happy camper. I didn't really want to get in to messing with POI.

Long story short: we will always have to work with spreadsheets because that's what "business users" understand (read: as flat as possible). ColdFusion 9 has built-in features that make reading and creating spreadsheets much easier than it's ever been. I'm excited about this and think you should come out to the next meeting on January 14, 2010 to learn more!

Benchmarking and Analytics Toolkit for Higher Education powered by Adobe ColdFusion and Flex

Tue, 25 Aug 2009 17:27:00 -0400

Earlier this year one of our projects went from soft-launch mode to officially "live" mode: The CASE Benchmarking Toolkit, a system we designed and implemented for CASE, the Council for Advancement and Support of Education. CASE represents over 2000 institutions of higher education worldwide with over 75,000 members.

Technical Specs

Interface: Flex 3.3
Backend: ColdFusion 8
Database: Microsoft SQL Server 2000

Integration with their member management and AMS/CRM system, iMIS.
Consumes data provided by IPEDS.

The Toolkit enables the CASE research division and interested communities of practice¹ to build quantitative benchmarking surveys, collect data, generate reports (text and graphical) and design summary dashboards through an easy-to-use interface. We wanted to share a little bit about what it does, why this is great for the alumni relations and advancement profession and why we as Adobe fans are so proud to have built it.

History

The origins of this project start back in 2005 with our friends at PCUAD. We implemented a surveying and benchmarking system for them that reduced the amount of time required to collect, output and analyze the data gathered from thirty higher education institutions. The "Alumni Relations Assessment and Measurement Program" (ARAMP) was the first attempt by any community of practice organization to quantitatively measure the performance of an alumni relations operation. It was an overnight success and continues to be used by PCUAD. About a year later we replaced the HTML UI with a Flex-based UI for use by the North East Alumni Relations group (NEAR).

Word got out pretty fast that PCUAD had not only created a great survey to 'measure' Alumni Relations but also the software to back it up. PCUAD was all too happy to help us get connected with the team at CASE to see if we could push this forward as a global benchmarking system. Once the decision was made to move ahead, we set about redesigning everything - the data model, the middleware and especially the user interface to work seamlessly with the CASE CRM system (iMIS - also a ColdFusion-powered product!)- using the experience we gained supporting PCUAD and NEAR to inform our decision making.

We delivered the system to CASE in February 2008 for beta testing, flipping the "go-live" switch in May.

Perhaps more importantly, we delivered the system to them on time and under budget.

Fast, integrated survey creation

Administrators can whip up a survey in next to no time. The CBT supports a wide variety of question types including question matrices. The system strongly encourages question reuse and enables the cloning of questions, sections and even entire surveys. It is through this capability that year-over-year data can be compared and analyzed. Since the user directory is fully integrated with iMIS, assigning permissions can be done anywhere within CASE which makes provisioning and access control a piece of cake.

Pain-free survey taking

For starters, this product is not Survey Monkey. Responses to surveys are intended to reflect institutional (not individual) performance; for any given survey many people from an institution can work on it but there is only one submission per school. This allows us to aggregate and filter the reports by specific institutional characteristics. Assistive text is available for each question in a survey, which when it comes to financial reporting is absolutely crucial. There are many ways to tabulate donations, donors, volunteers and many other aspects of a modern-day advancement organization.

Reporting and Exporting

Reporting is also a breeze. We know that advancement professionals use a lot of Word and Powerpoint documents in their line of work so we made it really simple to get exactly what they want from the available survey data. Not only can you select which of the available criteria to filter on, but you can view charts and graphs, calculate aggregate values and export it all to Excel (report data) and jpg (charts). We found that using ColdFusion to generate the appropriate data and Flex to render it was a very efficient, powerful combination.

Filtering report data was done through a very straightforward interface based on research and design we did for our RecruitWeb product. Criteria are displayed down the left side of the screen for selection; each item carries with it additional parameters that are user-defined. Use of colors to indicate active filters and the translation of selections to "plain English" gives the user a very good idea of what they can expect to see in the requested report.

Aggregate values are calculated for multi institution reports and privacy is protected for specific types of surveys under certain circumstances. We learned just how protective advancement professionals are of their financial data yet found a way to present actionable and useful information without compromising privacy.

Screenshots

What's ahead

Overall, we're extremely pleased with what we were able to deliver. ColdFusion made the middleware and business logic a snap. Flex allowed us to prepare a rich, responsive user interface. Using Flex also provides the server with some additional scalability. Similar to an ajax-powered application, the less we have to generate and send over the wire the more resources are available to support a larger number of connected clients.

Thinking ahead, it would be great if we could deliver an AIR application to enable push messaging - new survey notifications, even faster desktop reporting and possibly even survey completion alerts. The more data this system contains the more valuable it becomes to all of the CASE member institutions. The more tools we can provide that encourage people to participate the better!

1. A "community of practice" is an assembly of peer institutions connected by similar characteristics like alumni population, annual fund budget, or undergraduate population - not the traditional groupings like "Ivy League" or "Big 10." This ensures an "apples to apples" comparison of data for each discipline represented by the toolkit.

ColdFusion 9: ORM, Part 2

Mon, 03 Aug 2009 11:56:00 -0400

In part one I dipped my toes into the world of ORM in ColdFusion 9. Today I'm diving in...and I know there's far more to this than what I'm about to try, so there may be a Part 3 yet to come. As with part one, I'm writing this as I go...mistakes and all.

Today's challenge: get the rest of the spreadsheet imported into a more relational format.

The source data has a set of columns for payment information, which is great if you only want to keep the most recent payment information. Likewise, there's one column called "comments" that looks like it'll grow to be kinda nasty over time.

Ideally there's a one-to-many relationship between a person and payments and a person and comments. So how do we do that in an ORM configuration?

Step one is to create a CFC for a comment, as that is somewhat more simple.

Once again we've defined the CFC as "persistent" so Hibernate knows about it. As before we set the primary key field by defining the fieldtype and generator attributes on it.

The second property is the fun one. Usually when we're building a database, we'd reflexively put "personID" as a foreign key on the table. Remember, though, that what we're trying to capture here is the relationship between two objects. A comment "belongs to" a person.

Deconstructing the attributes:

cfc: the actual cfc object that this property references (person is in the /chiomega/mms folder)
fkcolumn: I like to use the PK of the referenced object as the FK column name in the database.
fieldtype: truly magical - there are "many" comments for "one" person.
lazy: don't get the data for the person until I ask for it

The options for Lazy Loading are many...and extremely worth the read. Any code where I can include an attribute lazy="extra" is beyond awesome to me! Quite honestly, though, how many times have you written a very large SQL statement with many join conditions, knowing full well you won't use most of the data but prefer to use one "getter" statement? Too many, right? No more. Let Hibernate take care of getting the data for you at the appropriate time. I could write a blog post purely on the subject of lazy loading and how great this is.

Back to the topic at hand: now that we've got a "comment" object with a relationship to "person" defined, let's look at the "person" and set the inverse relationship.

That last property says that each person has a property called "comments" that is an array of "comment" entities of type "chiomega.mms.comment".

Whoa. Break it down:

singularName: in a "one-to-many" scenario, what we're referencing is plural...but there's also a need (which I'll clarify momentarily) to reference the items individually.
type: valid types are array and struct. An array makes sense for this example.
fieldtype: the reverse of what we had on the "comment" entity. Each person can have 0 or more "comment" objects.
cfc: the type you're referencing, in this case the cfc we just created
fkcolumn: the column in the "child" table that will represent this "person"; recall that we set fkColumn in the "comment" entity to "personID"
cascade: When I save a "person", save any child comment records that exist (insert or update) on the person. Also goes for delete operations.

singularName is incredibly useful: this is used to define the auto-generated add/remove methods for the related objects. Read more on what's created for you in the ColdFusion 9 docs.

The "cascade" attribute was a trial-by-error discovery. There's a cascade options section in the docs on your choices here - basically it defines how the relationship behaves on save/update operations. If you get a object references an unsaved transient instance - save the transient instance before flushing error, this is why -- go back and set a cascade on your parent entity so that child operations work properly.

That should do it for configuration. Let's tie it together and import people and comments from the spreadsheet again.









	
		obj = EntityNew("person");
		obj.setFirstName(sheet["FIRST NAME"][sheet.currentRow]);
		obj.setLastName(sheet["LAST NAME"][sheet.currentRow]);
		obj.setAddress1(sheet["ADDRESS"][sheet.currentRow]);
		obj.setAddress2(sheet["APT"][sheet.currentRow]);
		obj.setCity(sheet["CITY"][sheet.currentRow]);
		obj.setstate(sheet["STATE"][sheet.currentRow]);
		obj.setPostalCode(sheet["ZIP"][sheet.currentRow]);
		obj.setPhoneNumber(sheet["PHONE ##"][sheet.currentRow]);
		obj.setEmailAddress(sheet["EMAIL"][sheet.currentRow]);
		obj.setProfession(sheet["PROFESSION"][sheet.currentRow]);
		obj.setChapterName(sheet["CHAPTER"][sheet.currentRow]);
		obj.setInitiationYear(val(sheet["INITIATION YEAR"][sheet.currentRow]));

		if(sheet["COMMENTS"][sheet.currentRow] is not '')
		{
			commentObj = entityNew("comment");
			commentObj.setNote(trim(sheet["COMMENTS"][sheet.currentRow]));
			commentObj.setCreateDate(now());
			obj.addComment(commentObj);
		}
		
		entitySave(obj);

"obj" is my person. If we want to import a comment, we'll create a new entity of type "comment". Recall that these entities have getters and setters automagically created for us, so I populate the note and createDate properties of the comment with values from the spreadsheet.

Once the comment is populated, I "addComment" to the person - the addComment is one of those automatically generated methods. Something I learned since the last post is that calling ormFlush() isn't necessary - at the end of the request it's called implicitly.

That was easy! Following the same pattern, I added an entity for payments:

...and configured my 'person' to reference them...

Then tweaked the importer to add those as well:






	
		obj = EntityNew("person");
		obj.setFirstName(sheet["FIRST NAME"][sheet.currentRow]);
		obj.setLastName(sheet["LAST NAME"][sheet.currentRow]);
		obj.setAddress1(sheet["ADDRESS"][sheet.currentRow]);
		obj.setAddress2(sheet["APT"][sheet.currentRow]);
		obj.setCity(sheet["CITY"][sheet.currentRow]);
		obj.setstate(sheet["STATE"][sheet.currentRow]);
		obj.setPostalCode(sheet["ZIP"][sheet.currentRow]);
		obj.setPhoneNumber(sheet["PHONE ##"][sheet.currentRow]);
		obj.setEmailAddress(sheet["EMAIL"][sheet.currentRow]);
		obj.setProfession(sheet["PROFESSION"][sheet.currentRow]);
		obj.setChapterName(sheet["CHAPTER"][sheet.currentRow]);
		obj.setInitiationYear(val(sheet["INITIATION YEAR"][sheet.currentRow]));
		
		if(sheet["COMMENTS"][sheet.currentRow] is not '')
		{
			commentObj = entityNew("comment");
			commentObj.setNote(trim(sheet["COMMENTS"][sheet.currentRow]));
			commentObj.setCreateDate(now());
			obj.addComment(commentObj);
		}
		
		if(sheet["DATE"][sheet.currentRow] is not '')
		{
			paymentObj = entityNew("payment");
			cleanAmount = trim(sheet["PAYMENT"][sheet.currentRow]);
			cleanAmount = replace(cleanAmount, "$", "");
			paymentObj.setAmount(val(cleanAmount));
			paymentObj.setPaymentType('check');
			paymentObj.setNote(trim(sheet["CHK ##"][sheet.currentRow]));
			paymentObj.setPaymentDate(sheet["DATE"][sheet.currentRow]);
			
			obj.addPayment(paymentObj);
		}
		
		entitySave(obj);

And, best of all, I haven't written a single line of SQL nor have I gone in and created tables/columns/relationships/constraints in the database, yet I have this ready and waiting for use:

Up next: building an actual application using what we've just created. I'm pumped...this is working out great so far!

ColdFusion 9: ORM, Part 1

Sun, 02 Aug 2009 00:38:00 -0400

So the challenge tonight is to bang out a quick little member management system using the ColdFusion 9 ORM tools. Basically, a test of the "look, ma, no code!" approach to software development.

Step 1: create blank database:

Ok, so that was boring. Next step: make a basic CFC using ColdFusion Builder's CFC generator. All I specified were properties that I expected to map to columns in the database. Still haven't written code - here's what was generated for me.

So far, pretty simple. Had to fight the urge to create getters and setters for each property...we'll let the ORM engine take care of that for us. I saved this CFC in person.cfc under the application's home directory in my webroot.

Next step: setting up Application.cfc.

The only three lines that are different from our "usual" config are this.ormenabled, this.datasource and this.ormsettings. The first tells ColdFusion to pay attention to our CFCs and automagically configure the ORM mappings for us. The second is another new feature of ColdFusion 9 - it sets a "default" dsn for all cfquery and cfstoredproc tags so we don't have to type datasource="#request.dsn#" anymore. Rock! Also, the ORM engine uses this value as the database to persist CFC data in. The third tells the ORM engine that I want it to create the necessary database tables and (when the time comes) log all the sql statements fired by the generated code. You'll see those log entries fly by if you start up CF from the command line.

Total code CF code written so far: three lines. Awesome.

Consulting the docs, I now need to add a few attributes to the cfcomponent tag to have the table created in the database for me.

...

Let's look at what I added:

persistent="true" - think of it to mean "please store the properties of this cfc as columns in a table you create for me"
fieldtype="id" - this is the primary key field
generator="increment" - I want it to auto increment for each new record (I'm using MSSQL05 for this example)

so far so good, I think.

So let's take a peek at what happens when I run a simple script.



	obj = EntityNew("person");

Nothing too special - it's just a cfc. But this is where the new hotness resides:

So let's jack some data into the db using this new hotness. Please note: the spreadsheet I'm using has the typical "not created by a programmer" column names with spaces, so I'm using array syntax to extract the field data.






	
		obj = EntityNew("member");
		obj.setFirstName(sheet["FIRST NAME"][sheet.currentRow]);
		obj.setLastName(sheet["LAST NAME"][sheet.currentRow]);
		obj.setAddress1(sheet["ADDRESS"][sheet.currentRow]);
		obj.setAddress2(sheet["APT"][sheet.currentRow]);
		obj.setCity(sheet["CITY"][sheet.currentRow]);
		obj.setstate(sheet["STATE"][sheet.currentRow]);
		obj.setPostalCode(sheet["ZIP"][sheet.currentRow]);
		obj.setPhoneNumber(sheet["PHONE ##"][sheet.currentRow]);
		obj.setEmailAddress(sheet["EMAIL"][sheet.currentRow]);
		obj.setProfession(sheet["PROFESSION"][sheet.currentRow]);
		obj.setChapterName(sheet["CHAPTER"][sheet.currentRow]);
		obj.setInitiationYear(val(sheet["INITIATION YEAR"][sheet.currentRow]));
		entitySave(obj);

Those last two lines are the fun part and should be explained. entitySave causes Hibernate to store the object in its own cache for really, really fast retrieval. To actually get the data written to the database, we call ormFlush(). If the object has been changed, it gets pushed to the database. In this example, 245 records are created in the cache, then all written out to the database.

Our database:

So now that all of that info is loaded into the database without having written a single line of SQL (c'mon, don't act like you're not impressed), let's slap together a quick browse interface. Do not use this code as an example of "how to write CF"...it's a hacktacular approach just to show the basics. Please.

In "old school" code we would have had to write a query to get any of this data out of the db. Instead, we're asking the ORM engine to do all the heavy lifting. You can see that we're adding a match between the personID field and the form field of the same name. You can specify as many matching criteria as you wish, again without writing any <cfif> this or <cfelse> that.

The result (blurred for privacy reasons):

In my next post, I'll create the edit form AND start working on the one-to-many relationship between a person and a "comments" table. This is where we'll get the most utility out of ORM, but also where we'll find the most complexity.

So far, though, I'm totally impressed. This really was my first experiment with ColdFusion's ORM capabilities. There's plenty more to learn and I'm sure I'll refine my technique even more as I dig in to it.

CFSpreadsheet

Sat, 01 Aug 2009 22:32:00 -0400

It really is this simple in ColdFusion 9:

No more cfx_Excel2Query, no more hacks, no more funky parsing...just straight up Excel to a native ColdFusion recordset.

Up next: creating a simple app using the ColdFusion 9 ORM capability. This is tonight's programming challenge.

Adobe Community Expert

Thu, 12 Feb 2009 11:31:00 -0400

I got some great news yesterday from Adobe informing me that I've been invited to join the Adobe Community Experts group for 2009!

The community experts program (and forgive me if I quote directly from the site here) "is a community based program made up of Adobe customers who share their product expertise with the world-wide Adobe community." Kinda like what I used to do with the Philly CFUG, but on a broader scale. We're expected to attend and present at conferences, write frequently (on actual paper and online), and make ourselves available to others in the community who want to learn more.

I'm happy to be a champion for ColdFusion and Flex (and other Adobe tools) and look forward to making an even more active contribution to the community this year!

QueryParam Scanner

Tue, 22 Jul 2008 17:00:00 -0400

Time to step back and check your work...

Every now and then it's worth taking the time to run a scan tool against your always-growing codebase to make sure you haven't opened up any avenues for a SQL injection attack.

You'd think that after so long and so many repeated warnings we'd all be tighter than tight now and that param-ing our queries would be second nature. This is such an old vulnerability for any webapp and building in fault tolerance from the start should be elementary. For the most part that's absolutely the case...but there are always a few queries that manage to get by without wearing proper protection.

I was a bit surprised at the results after running the QueryParam Scanner tool from RIAForge (thank you. Peter Boughton!) -- until I realized that the tool isn't excluding SQL in a query of queries (dbtype="query") nor is it omitting any values that are being set from an unadulterated CF function (now() is one example). Still. though. it did identify a number of queries that needed a little extra attention just to be truly safe from attack. I highly recommend that you go get it and run it today. You can clean up the mess before you leave work today. This would be an excellent feature to be written as an extension to CFEclipse or (as Rob Brooks-Bilson suggested) integrated into standard CF unit testing suites.

Worth noting is that in many cases (at least for the numeric params) we val the value and set the type on the cfargument tag in all the CFCs all the way down to the DAO level so even without the cfqueryparam tag we're mostly safe. It's those char/varchar fields that require the most attention (complete with trim(). left(). and maxlength checking!) to be considered sufficiently safe.

All of that aside. cfqueryparam alone is a strong first step to protecting your system from a SQL injection attack. Using it reduces the likelihood you'll be wearing egg on your face on Monday morning!

Get ready for "boom"

Fri, 01 Feb 2008 18:31:00 -0400

The blog has been dark for about a month. but the office has been anything but.

We've been working a lot - way more than we expected - to get our projects done. We've done great at delivery. with upgrades to our faculty evaluation system pushed out the door on time (followed by a trouble-free reporting cycle). a brand-new award nomination system launched last night (basically a build-your-own form generator) and a soon-to-launch software project documentation/lifecycle tracker for one of our favorite clients (you know who you are!).

We're now in the final 48 hours of work on a slick Flex-based benchmarking survey suite. The final 48 hours of a 7 month project that has cost Matt more than enough sleep and both of us a nice slice of youth. HOWEVER...it's a beautiful thing and will give our client the ability to support and encourage the growth of their clients in a way that hasn't been done on this scale before. I can't wait to post screenshots and show off what we accomplished. This application integrates data from two outside databases. compiling and calculating additional data on top of it. and providing a rich reporting UI that includes Excel export and on-screen chart creation. Flex makes the graphical and user interface elements of the project so much more attractive! We're also expecting a heavy load. which we're feeling more comfortable about supporting through the offloading of a lot of work to the client through the use of Flex and web services. Can't wait to get it pushed live!

Also coming down to the final week is our long-discussed Online Community project. We've been focused on making it a stunning and useful experience and at the same time adapting features to meet last minute shifts in requirements. This isn't another Facebook/MySpace/Ning site - this product is for colleges and universities to use. The OC provides a high-content. simple-to-use and CRM-oriented platform for alumni to reconnect with one another and their alma mater. Lots of time has been spent balancing the integration needs of the institution (always interesting) and ease of use - at this stage I'm convinced that few other online community vendors in this space have considered these issues as thoroughly as we have.

The OC has been previewed to a few people (and they've been impressed). but next Saturday is the "big one" - the feature-complete dog and pony show that will either excite the heck out of them or make us wonder where we went wrong. Early indications are positive. but we've got a ways to go to be ready for it. I'm going to steal as many ideas from Steve Jobs as I can for the Powerpoint portion of the talk - possibly even the attire!

So that's where we've been: working on a ton of Flex. kicking out a little bit of inspired ColdFusion and spending lots of time in meetings. A couple weeks from now we'll post screenshots (and probably put the community up on Labs for folks to play with). Our clients are eager to get these projects wrapped up. so back to work I go. We're doing great and we'll be doing even better after go-live!

Get on the Bus!

Fri, 14 Dec 2007 18:08:00 -0400

The Enterprise Service Bus. that is...

Rob Brooks-Bilson is doing a mini-series of posts on what an ESB is and how you might work one in to your ColdFusion environment.

An ESB is a great platform-neutral. SOA-way of integrating disparate systems using common technologies like web services. FTP. email. ftp and more. Yes. there's FAR more to it than that...but if I went in to detail. there'd be no reason to read Rob's post.

Can't wait for the next installment - we've got a couple big projects that would benefit greatly by being "on the bus" for data exchange!

CFEclipse on Flex Builder 3 Beta 2

Wed, 24 Oct 2007 10:20:00 -0400

I figured I would try to spend a day with FB3 to see how it's coming along (so far it seems a little faster). Of course. we do a lot of ColdFusion development so CFEclipse is pretty much a requirement.

However. I could not install it due to some missing files in Eclipse. Thankfully. Joao posted instructions on how to correct this and get CFEclipse working on FB3b2.

Thanks. Joao!