We're still working out what's coming down the pike, but improvements will include:

• A more organized and useful API to the database introspection piece.
• A better template system
• A configuration creator and editor

It's all towards making Squidhead more useful and extendable. Expect new releases soon.

It's powered by ColdFusion 8, and Flash Video. I worked on the backend details: hosting, network configuration, database CRUD. My co-worker Sanjay did the design and UI, and my boss Dave, did the Flash video setup. The time it took us to go from mockup to finished product was very short - we did this much quicker than I had done before for non-personal project. I know it isn't a huge site, but after years of working on nothing but backend systems that never get seen by the public, it was extremely satisfying to work on something that wasn't behind a corporate login.

A couple other things make me happy about this. Squidhead powered backend development, which made dealing with last minute schema changes a snap. It also used the core application framework that I've been developing for Knowledge. It was the first project we did with the new one click build process. It uses unfuddle.com, SVN commit hooks, ANT, and ColdFusion calling ANT to allow for:

• Automatic publishing of SVN checked-in content to a shared development server
• 1 Click publishing of checked in content to a shared development server (In case automatic is too slow)
• 1 Click publishing of shared development space to staging
• 1 Click publishing of staging to production
• 1 Click publishing of SVN checked-in content to development to staging to production

This new model allowed for both a thoughtful develop and review process during development, and was flexible enough to allow for rapid content updates when we were rolling out production.

All in all, it was awesome to use all of the stuff I learned about over the past two years at cf.Objective to do my job.

For this example, I am sharing the code for documenting "steps" in Squidhead. Steps are operations that do one thing, like generate stored procs, or ant scripts, or email developers. They are powered by cfm templates in a specific folder. Once there they can be referenced through in the project's config file. The documentation for them is included in the download for Squidhead, and can be viewed online (Squdihead - Steps).

So after the jump, here is the code for creating this documentation.

New features:

• Oracle Support
• Linux Support
• Linking table support
• FKCrazy Application template
• Rudimentary ColdSpring Support

Squidhead will run against Oracle 10g. It alters its model a bit to create stored procedures within packages, as this seemed to be in keeping with Oracle Best Practices.

Squidhead will run on Ubuntu. I haven't tried it in other flavors yet, but I can't tell why it wouldn't.

If you follow the convention of naming tables [table1]To[table2] and have the primary keys from table1 and table2 as foreign keys, Squidhead will recognize the table as a linking table. It will create stored procedures that pass queries through this linking table to create relationships between linked tables.

FKCrazy application will use the linking table information to automatically create interface that uses all of the foreign key relationships to add and delete child records. It can do this in a one to many relationship, or in a many to many relationship. Translation: If you've seen my Facebook in 17 minutes presentation - everything I did manually at the end now happens automatically. So if I did it today, it would be more like Facebook in 12 minutes.

Squidhead can create its own ColdSpring configuration files. Not earth shattering but makes integrating a Squidhead application with an application already in ColdSpring much easier.

So there you go, quite the update over the past few weeks.

Microsoft SQL

This was the first one I started with, so the others are being compared to it. It comes with the built in stored procedure sp_help, which is absolutely brilliant. It gave more information for tables than I ever needed. It also gives most of the information for a stored procedure that I need. Although there are a few things lacking which made me have to resort to using sp_helptext, and then parsing the actual stored procedure. I had to do this to get the number of result sets that a stored procedure returns. (Because if a stored procedure returns more than one record set, Squidhead writes the method to return a structure of queries instead of just a query. ) Also I had to do this to get the metadata of the arguments being passed to a stored procedure.

MySql

Of the three this was the easiest to do. I had a flash one night ("just implement sp_help's queries in MqSQL") and it took me less than 24 hours to add it. Nonetheless I still had to query a lot of system tables directly to get the results I wanted.

There are few other limitations that bug me, but they aren't related to code generation. Things like stored procedures not being able to take default values in their inputs, and views not being able to contain subqueries. I'm sure as those features mature though, we'll see better results there.

Oracle

Finally, we reach Oracle. It took me a week of hair pulling, keyboard slamming and muttered curses to get it right. But finally I did.

What I didn't like:

One has to create a cursor to contain output recordsets for a stored procedure. That's so different than the other systems that I wanted to kill someone. Although, I must confess it makes counting output record sets much easier.

That everything is limited to a name length of 30 characters. So I had to get creative with how to deal with stored procedures with names like usp_entryToComment_list_foreign_key_labels. The solution I came up with was to abbreviate them and rename them higher up in the Squdihead stack so that the functions have the "correct" names.

What I liked:

Packages. Packages are sort of like classes or CFC's for Oracle operations. The encapsulate code into discreet chunks. I basically create a package for every table so my stored procs have names like ENTRYPKG.READ which is better in my mind than usp_entry_read as that's just a way I use to group and sort stored procedures anyway.

The sheer amount of data in the various data dictionaries. I don't have to parse any code strings to get any metadata. That's much easier.

"CREATE OR REPLACE." Truly awesome. Cuts down on the amount of steps I have to do to recreate a stored proc or package. I wish I had known it exists for MySQL.

Conclusion

It's kinda funny, and it may be cognitive dissonance talking, but of the three, I really like Oracle the best for code creation and metadata. Overall, I still lean towards Microsoft Sql as it is the one I know the best. Also whatever your thoughts on Microsoft Sql Server Management Studio, it's so much better than SQL developer for Oracle. But that's a completely different topic.

I'll be going over the reason behind the application and what it can do. As for the demo, have you seen my Facebook in 17 minutes demo? Well, I'll be doing that, in about half the time. (I've made some improvements to Squidhead in the interim.)

"I don't know," I replied.

So now I have one. Feel to join and pester myself and the 2 other people that will join.

Squidhead ColdFusion Code Generator

1. I'm using to it to build a more complex application
2. I talked to a few people about it, and they actually liked it

But it occurs to me that I could/should do a better job explaining why you might want to give it a longer look.

Squidhead might be for you if:

• You or your organization requires a generator that uses stored procedures instead of inline SQL calls
• You or your organization prefers using foreign keys and wants a generator that can use them to discover business logic
• You want to fool around with code generation but don't the like MVC code that many of the others use.

Squidhead might give you an excuse to:

• Work with Ant, because of the build.xml files it creates for itself.
• Experiment with Unit Testing, because it builds its own CFUnit Tests and runs yours too

Squidhead isn't for you if:

• You find the name "Squidhead" ridiculous.
• You're already using a more established generated or framework

If you're interested, here are some resources for you:

• Squidhead at RIAForge
• Squidhead documentation online

Sorry about that.

I've fixed the Flash version and it shouldn't do that anymore. I should have gone with Flash Video encoder in Flash CS3 from the get go.

Flash Version

Then I thought about ColdFusion 8 and its image capabilities, and the image CRUD that I've added to Squidhead and thought maybe a facebook type application would be more compelling. So I did it, and put it up on Google Video. (cause I couldn't get it under 10 minutes.) Then I saw it on Google video and was repelled by the quality of the video. So I have few options to watch it below.

I show off three features of Squidhead in the video:

• Image CRUD interface
• Foreign Key usage
• Scaffolding your stored procedures.

If anyone watches it, please let me know what you think.

UPDATE: It appears that the Flash Version will cause your computer to crash. Sorry about that. I will have a replacement up at some point in the very near future.

UPDATE:Flash Video version works now.

• Google Video Version (pretty blurry)
• Flash Version (Takes a long time to download)
• Windows Media Version (download, still pretty long to download)

Before I started rewriting, I spent some time developing more applications with Squidhead. I figured out a couple areas of inefficiency and tried to fix them when I could. Creating configuration files took longer than it should and was a bit confusing. I found myself writing Ant scripts for all of my applications. I kept forgetting to test my applications.

Further when I was maintaining the actual Squidhead codebase, some things were frustrating. Maintaining a separate code base for ColdFusion 8 and ColdFusion 7 was a pain in the ass. Maintaining a simple version and a business version was a pain. Adding new features required a series of cascading tweaks because it was poorly architected.

So here are the solutions to all of those issues and a few more for good measure.

New features:

• MySql 5.0 Support
• It creates Ant Build files for common tasks
• It can run CFUnit tests that it creates during its build
• It now will use CF8 rich elements it the generated crud *
• It now handles images *
• It's now a little easier to extend
  • It's easy to add steps.
  • It's possible to add application templates
• Modified XML configuration allows developer to override certain defaults like form field labels.
• New Configuration Builder
• New Shiny Web 2.0 looks (Okay, not a feature per see.)
• Cheesey Web 2.0 Logos created for every application.

* CF 8 features can be turned off if application will not be running on a CF8 server.

Deprecated Features:

• Simple Applications (They are still available, but they won't be updated)

Removed Features:

• Threading (Speed Enhancements weren't enough to justify added complexity)

Requirements:

• Squidhead: ColdFusion 8
• Database: Microsoft SQL 2000 or 2005; MySql 5.0
• Generated Application Using MSSQL: ColdFusion 7 or 8
• Generated Application Using MySql: ColdFusion 8

Notes:

• For the most part, your old config files will still work. However the more changes you made the more likely they are to have problems.

Old versions of Squidhead still available at http://www.numtopia.com/squidhead.

The new version is available at Riaforge.

Since I'm trying to highlight the ability to add steps to Squidhead applications, I was thinking that it might be cool to not just write the tests as part of the Squidhead build, but also run the tests as part of the Squidhead. Including the ColdFusion autorunner for the reports didn't work. Because both CFunit and Squidhead rely on <cfflush>. So I fired up CFAnt to see if it would run. It didn't. It through an error that stated: BUILD FAILED… askdef class net.sourceforge.cfunit.ant.CFUnit cannot be found.

I copied the version of cfunit-ant-v3-alpha.jar I use with Eclipse to my ColdFusion8/lib directory, restarted the server and voila: BUILD SUCCESSFUL.

Ant in ColdFusion is cool.

Oh and I imagine the same tip would help you to run CFCUnit tests to run from <CFAnt>

It's gotten a little unwieldy to do updates for both a ColdFusion 7 and 8 version of the feature set. Additionally, the whole business objects and non-business objects version is also getting hard to support. Finally, there are a whole bunch of features I would like to support but require ColdFusion 8. So here is what I am proposing:

• Ceasing development of the current version of Squidhead.
• Starting a new development track that required ColdFusion 8 for application generation. (But then generated application could run on ColdFusion 7.)
• Dropping the non-business objects version of the code.

Once I did that, I could do the following:

• Switch database analysis over to use <cfdbinfo> for most, but not all of what I do.
• This would make adding support for other DBMS's easier

I'd be happy to hear any feedback you might have on these proposals. Assuming no one objects, I would publish one last version of the old code as 1.0, and then start pruning and working on what I would call version 2.0. (I would also come up with a more standard versioning system.)

I originally started fooling around with unit testing because after drinking Pragmatic Programmer Kool-Aid, and attending cf.Objective, it was the next thing on my list. I figured I would be pulling them into Squidhead, as it's pretty easy to tell if Squidhead worked (the application is either written or not,) but it's hard to tell if the created application is working. So I started to write unit tests for my DAO Objects figuring it would be an easy place to start. Once I got one working, I realized it was relatively rule based and could stand to be generated itself.

What it does is:

• Create a mock struct of the record.
• Create a mock struct of the record slightly different from the first.
• Create a record from the mock record.
• Read it back and compares it to the source.
• Update it according to the different mock record.
• Read it back and compares it to the source.
• Delete the record
• Read again to make sure the item is gone.

All that is wrapped in a <cftransaction> making sure the thing never happened. Additionally it reads in and honors foreign key constraints. It's got some weaknesses: it doesn't like binaries or images; its smalldatetime check is only accurate to the hour; and there are probably more bugs lurking.

Now once I got them working, they were in, but what's the point for users of the application? One should expect that the parts work.

So to make this worthwhile I added some logic that will run any test that is in the test directory structure. So if you're using Squidhead and looking to dip your feet in the waters of CFunit or unit testing in general here's your chance.

If you're wondering why CFUnit, and not CFCUnit, it's because as far as I can tell CFCUnit requires Mach II, and I figured one requirement was better than two.

So if anyone has any suggestion on how to test gateways or dao's I'd be curious. Otherwise check it out.