Good news, it's an easy fix. You'll soon have a nice high-resolution icon for both your dock icons and Eclipse.app.

1. Save the Coldfusion PNG from Wikipedia (http://en.wikipedia.org/wiki/File:ColdFusion_icon.png) to your hard drive
2. Convert the PNG from step 1 to an ICNS and save back to your hard drive. (I used iConvert http://iconverticons.com/)
3. Open /Applications/eclipse (or wherever you installed Eclipse)
4. Right click on Eclipse, select Show Package Contents
5. Go to Contents > Resources
6. [Optional] Rename Eclipse.icns to Eclipse_old.icns
7. Copy Eclipse.icns from step 1 into the Resources folder
8. Launch Eclipse
9. Enjoy.

You should then see something like this:

The basic usage is pretty similar to another oh-so familiar tag:

<cf_yql>
Select * from flickr.photos.recent
</cf_yql>

<cfloop query="cfyql">
 <!---Format of the static urls to flickr images--->
 <cfoutput>
   <img src="http://farm#farm#.static.flickr.com/#server#/#id#_#secret#_s_d.jpg" />
 </cfoutput>
</cfloop>

Creates...

As you can see, the format is pretty similar to cfquery. The table name "flickr.photos.recent" is table supported by the YQL (for a full listing of available tables see the footnotes).

Here is another example using an RSS feed:

<cf_yql format="query">
select * from rss where url='http://rss.news.yahoo.com/rss/topstories'
limit 5
</cf_yql>

<cfloop query="cfyql">
 <li>
 <cfoutput><a href="#link#">#title# &mdash; #Source# &mdash; #pubdate#</a>
 <div>#description#</div>
 </cfoutput>
 </li>
</cfloop>
</ul>

Creates...

In the future, I'd like to take this further by using YQL's newly added 'execute' functionality.

The project is hosted on github. Feel free to fork me or download the code here.

Edit: Yes, I know this looks like Ray Camden's cf_yql example (http://www.coldfusionjedi.com/index.cfm/2009/9/10/Yahoo-Query-Language) posted earlier today (9/10/09). I had written this post originally on 8/28 and just never got around to publishing it. Ray just lit a fire under my arse by posting his, so thanks Ray!

Break up Select, Insert and Update

Nothing is harder to read and debug than:


Insert Into NotNormalizedTbl (firstname, lastname, address1, address2, is_dog_lover, has_dog, dog_breed) Values ( 'Jon', 'Dowdle', '4000 Central Florida Blvd', true, true, 'mutt');

Even though this is a simple statement I find it takes a while to identify which column is missing.
Here is the same example but with each column and value on its own line.


Insert Into NotNormalizedTbl
(
firstname,
lastname,
address1,
address2,
is_dog_lover,
has_dog,
dog_breed
) Values (
'Jon',                       /* firstname */
'Dowdle',                    /* lastname */
'4000 Central Florida Blvd', /* address1 */
true,                        /* is_dog_lover */
true,                        /* has_dog */
'mutt'                       /* dog_breed */
);

Also, separate your Where conditions. Where a = 1 And b = 2 And c = 3 And.. isn't very easy to read. For the Where clause I like to keep each condition on its own line and indent each rule within the clause. This brings me to my next rule.

Indent

Indentation is next to Godliness, or so they say. My personal style is to indent as often as possible.

Consider:

Select * From table1 Inner Join table2 ON table2.id = table1.two_id

vs

Select *
From table1
Inner Join table2
On table2.id = table1.two_id
And table2.name = table1.name

Capitalize keywords

I know this sounds counter intuitive but let me explain the logic behind only capitalizing the first letter of keywords.

The reason for this is that the human eye picks up on the Capitalized Keywords while the ALL UPPERCASE WORDS are skimmed over (Proctor, R. & Vu, K. Handbook of Human Factors in Web Design. New Jersey: Lawrence Erlbaum Inc.).

Consider:

SELECT vs Select

Separate each clause

Don't leave items on the same line if they are from a different clause.  While this provides better readability it also has a bonus benefit: commenting out a rule is a snap. This is best shown in an example.

Select * From table1 Where c1 <> "" and c2 is not null

vs

Select *
From table1
Where c1 <> ""
  and c2 is not null

Comment

Just as with any code, the next guy/gal to read it might not be you. So when you're making the world's longest and most convoluted SQL statement, please comment what each part is doing and why.

Wrap up

To format existing queries I recommend using SQLInform (http://www.sqlinform.com/). It has a ton of options and has worked very well for me in the past.

Using these styles doesn't take very long to get used to, so give them a shot.  The next time you debug a SQL script you will thank yourself. Once again, leave any tips or practices that you find helpful to keeping your SQL clean and maintainable in the comments area.

This article's value can be seen if you've ever been in a meeting where 10 new "awesome"/"cool"/"really important" features have been introduced 3 months after the requirements have been completed. To a developer these changes can be frustrating (if we aren't the ones proposing) or exciting (if we propose). Either way leads to either a rejection of the idea or an over commitment of our time.

The best thing taken from this article is the questions to ask of each feature before it is decided to be in the next release. They are:

• What does the feature mean to its user?
• What does the user mean to the product? Potential purchaser, marketing partner, simple user, influential user, investor…
• What does the feature mean to the company or companies developing it?
• How would you rate feature on the Kano scale (Pre-Requisite, Positioner, Exciter or Deterrent)?
• What is the consequence of not implementing the feature?
• What is the consequence of delaying implementation of the feature?

Original article (AgileSoftwareDevelopment.com), Planning Poker (Wikipedia)

Quick Description
The iterator provides a single way to loop over a collection of elements without having to worry which type of collection (list, struct, array, query) it is. The interface for an iterator is quite simple with the main methods being hasNext() and next(). hasNext() returns true or false depending on if there are additional elements, while next() returns the next elements.

Speaking of collections, there is a collection class included with the source files. Using a class to contain the collection is preferable because it abstracts the data storage method for groups of objects, which lets us use the iterator class seamlessly. I find being ignorant of the underlying data type gives much more flexibility. I plan on going to more detail with the AbstractCollection and the implementation more in a future post.

Most of the code is taken from Brendan O'Hara's article, with the largest exception being the addAll() method in my PersonCollection.cfc. So again, many thanks to him for his wonderful post on CFDJ.

Included Examples:

• AbstractIterator.cfc
  • Abstract class (with CF8 this could be replaced with <cfinterface>)
• ArrayIterator.cfc
  • Class to handle iterating over Arrays
• PersonCollection.cfc
  • Maintains a collection of Persons
• Person.cfc
  • Basic class
• Test.cfm
  • Instantiates and displays output for all these CFCs

Links:
Iterator Source Files

Brendan O'Hara's Iterator Article

Also, I use the term "class" for "component" and "method" for "function". So without further ado,  my first article on implementing design patterns in Coldfusion.

Decorator Pattern

A decorator more or less wraps a base class and well...decorates it. This can be useful when you have a scenario that would need a lot of classes to cover all of the possible combinations of objects.

My Implementation

I followed the example by Hal Helms as far as the class organization is concerned.  Some of the decorators are me being funny (piglatin and mirror), but I can see some value in the TableDecorator, JsonDecorator and XmlDecorator.

Let me explain each file a bit more.

• Test.cfm
  • Instantiates the components and outputs results
• Person.cfc
  • Base class (whose methods will be overridden by the decorators)
• PersonDecorator.cfc
  • Base decorator class (all decorators for Person will inherit from this class)
• PersonJsonDecorator.cfc
  • Creates a JSON representation of a Person.
• PersonXmlDecorator.cfc
  • Creates a XML representation of a Person by wrapping the elements with nodes that represent each element
• PersonTableDecorator.cfc
  • Creates a table representation of a Person by wrapping elements with <td>'s and the entire Person with <tr>

Links

Source Files

Wikipedia's Page on Decorators

Hal Helm's Decorator Article

In the past few days I've accomplished quite a bit. The core functionality is not done, but some of the outlying features have come quite a way.

Below I've broken down the project into the most elementary functional units.

History

This last week I came down with one of those 'everyone is going to get it' colds. Luckily this roaming strain only kept most people out of work for 2 days at most. In the height of the sickness, I had a thought. Why hasn't someone created a warning system for these epidemic like colds? I, for one, would have appreciated knowing that everyone was contagious.

So this is where the idea came from.

Abstract

The project's goal is to allow users to watch for flares of ailments and to take precautions so that they may not miss work or pass diseases on to loved ones. What I believe sets this project apart is the speed of updates and diseases covered.

The CDC has a similar application but with the shortcomings that I plan to address. Their system is not directly user reported and only covers the Flu.

Input

To keep submission easy, I'd like to keep the input process as simple as possible. Data will be entered through a standard HTML form.

Five elements of information is the most that I want users to have to enter. In the K.I.S. mindset, so far I have:

• Zip code
• Symptoms displayed
• Household size

Future data elements might include:

• Taking any corrective medications, i.e. antibiotics?
• Seen provider yet?
• Length since symptoms began?

Output

I'd like to make the output as graphical as possible. The main reason being to keep this simple and intuitive.

The main element of output will be a map of the user's surrounding areas. The map will be a thematic map showing the degree of symptoms reported.

The above map is all that is planned for the first iteration. Ideas for future iterations include:

• Showing the velocity of symptoms
• Emailing alerts based on user criteria

Progress So Far

• Input
  • None so far
• Output
  • Chosen Google Maps to display output map
  • Generated county boundaries based on US Census GPS data
  • Dynamically displayed Counties in varying colors within Google Maps

Outside Links

Project hosting: Infection Control @ Google Code

Link to demo video

Link to Google video

To see it in action go here