• Thomas Jefferson University (Philadelphia, PA) is looking for a senior ColdFusion developer. Requirements include strong design and layout skills. Flash/Flex skills and experience with Model-Glue preferred. Details posted by Luis Mathews on his blog.

Oh, and the site background is interactive, and apparently there are hidden puzzles in there. Have you figured any of it out yet?

• Peoplexs (The Hague, Netherlands) is looking for a ColdFusion lead developer and multiple ColdFusion developers. Details posted online here and here.
• Unnamed client (Cleveland, OH) is looking for a ColdFusion contractor for a multiple week engagement. Requirements include experience with ColdFusion 8, DHTML, JavaScript, IIS, and SQL 2000/2005. Contact recruiter Derek Carle at Oxford & Associates.

I installed Firefox 3 on Download day, and made sure that it was a clean install. The only plugins I have installed are Greasemonkey and YSlow. It's a pretty simple and clean install.

And all is good initially. And then gradually my CPU utilization reaches 100% and the system grinds to a halt, and when I look at Windows Vista Task Manager I see that Firefox is using over 60% of my resources! Heck, it's more than Outlook uses! Is anyone else running into this one?

But times have changed. For starters, as ColdFusion has grown more all encompassing (starting in CFMX), so have the demands on the language - new features need new language elements, and thus language proliferation. In addition, there are other engines that execute CFML code, engines that perhaps do things that ColdFusion does not do or does differently, and vice-versa. And while every vendor and player in this space should have the luxury to innovate as they see fit, the more they do so, the greater the risk of further fragmentation and inconsistencies within the language.

Which is why there has been talk for several years now of transferring stewardship of the language from any single vendor to a committee or consortium. In fact, I remember being asked about just this while on a panel at CFUnited (or CFUN as it was known back then) quite a few years ago. But that never happened, for two reasons. One reason is purely one of economics. Simply put, could the ColdFusion team afford to spend precious engineering time on an effort that would take resources time away from core development, while essentially only helping competitors? And back then the answer was no, not at all. After all, which feature in CF7 or CF8 should we have sacrificed in order to do so? That's not an answer many want to hear, but it's the truth, and it's how I answered that question all those years ago.

But there is another answer too, and this is the answer I did not give because, well, frankly it would have opened up a Pandora's box that I just did not want to have to deal with at the time. For different organizations to work together on a project that less directly helps their own interests while at the same time requiring a degree of cooperation that could legitimately further the interests of the others parties, one important ingredient is required. It's called trust, and without it any collaboration between competitors is doomed, despite the best of intentions. And let's be honest, there has been little trust between the various players in this space. No, I am not going to get sucked into gossip or mudslinging or a he-says-she-says, that's beyond irrelevant. The only thing that is relevant is that if we are truly honest with ourselves we'll have no choice but to acknowledge that trust between the various players has been nonexistent. And no trust equals no cooperation, it's that simple.

So what's changed? Why is now the right time to truly start cooperating in the bests interests of the language and community that loves it and relies on it, putting those interests above those of individual organizations and products?

What's changed is that there are now players who truly do get along (as I noted in a previous post). Not that they did not get along previously, the relationships was always a very professional albeit neutral one. And that's a good thing. It's allowed for trust which has allowed for open communication which has allowed for the types of discussions that have not been possible previously.

And so at CFUnited this week we announced the creation of the "CFML Language Advisory Committee", a small group who hopefully will come up with the guidelines and standards and recommendations that will ensure the long term viability and integrity of CFML. The committee is a work in progress, and the details of its objectives and mandate and workings still need to be hammered out. But it's an important first step, and one that all involved are enthusiastically committed to.

In the interests of openness, and to ensure that no committee representation drowns out the voice of any other constituents, we were careful to not stack the deck in any way. The initial group of six is made up of two Adobe representatives, a Railo representative, and three community representatives.

And yes, there are stakeholders who are conspicuously absent from the initial committee. And as expected, that point was made by one of the first questioners after the announcement who wanted to know how the interests of other players would be represented. I answered the question bluntly and honestly, and tried to be as professional and measured as possible in doing so. And basically what I explained was what I already said above. Right now we've included those who respect the business requirements and necessities of the other players in the space, and those who have demonstrated a clear commitment to the community, looking out for its best interests. Of course, by inference I was saying that others are not meeting those prerequisite requirements, and understandably this has upset some.

But as I said before, the trust factor is critical. Here's an example. Yesterday, during the keynote, Adam Lehman demonstrated some of what we are planning around Hibernate-based ORM support in ColdFusion "Centaur". And as it so happens, Gert Franz of Railo has already stated that his team is working on Hibernate integration as well. Obviously, we need to work together. There is no requirement that we solve the same problems the same way, nor is there a requirement that the solutions be compatible. At the end of the day product teams should do what they believe is correct and in the best interests of their respective products and businesses. But we do need to work together as much as possible, doing so benefits the community and hopefully both of our eventual feature implementations. And that's just the one public example, there are many others.

And that's where the trust comes in. Not inviting some of the stakeholders initially is less about taking stands or punishing indiscretions or playing politics. It's about trust and the reality that where there is a history of distrust the frank and open discussion that this endeavor requires will be utterly impossible.

That's not to say that things can't change. They can, and hopefully will. For example, when one of the players in this space spins off a standalone community driven open source initiative, that represents an opportunity to start over, to divorce from prior ill-feelings and built up distrust. Has that opportunity been realized? That's debatable, and many have strong feelings on this one. And who's right and who's wrong is unimportant. What is important is that the fact that this is so hotly debated, the reality is that the trust is still not there. Not yet.

So, for now we have a new small and very focused "CFML Language Advisory Committee", one that will hopefully start to contribute in earnest immediately, one that will start to realize benefits for all involved, including the community. And as I explained yesterday, the committee is deliberately and intentionally not stacked or biased in any majority direction, and so the ability to invite and include other stakeholders in the future is a definite possibility.

Yesterday's announcement is an important first step, and one that I hope marks the beginning of a new era for CFML and for the community that has supported it for so long.

This is a really important program for ColdFusion. For starters, there is real interest in teaching ColdFusion, and we definitely need new to be training new developers. But additionally, there is significant interest in teaching RIA development in colleges and universities, and by making both ColdFusion and Flex Builder freely available for educational use, both ColdFusion and Flex benefit.

We had hoped to be able to announce the immediate availability of this program, but the process is taking longer than we had hoped, and is not available yet. So, bear with us a bit longer, and watch for an announcement within the next few weeks.

• CenterStone Technologies (Denver, CO) is looking for a ColdFusion developer. Requirements include strong ColdFusion, JavaScript, and SQL skills. Pluses include experience with jQuery T-SQL, XML, XSL, Web Services, object oriented programming, AJAX, SourceSafe, and experience with SaaS company model. Contact cfjobs@centerstonetech.com.
• Media Logic (Albany, NY) is looking for a ColdFusion developer. Requirements include a minimum of 3 years ColdFusion experience (ColdFusion 7 and/or 8 preferred), as well as experience with SQL Server 2000/2005, ActionScript 2/3 and Flash Remoting, JavaScript and XML. Details posted online.

To use the Yahoo! Maps AS3 Component you'll need your own Yahoo! Developer Network Application ID. If you have one already, then you're all set. If not, click on the "Get an App ID" link on the component page to obtain one.

Once you have an App ID, you'll need to download the Flex component itself. There is a download link in the middle of the component page, download the ZIP file, and expand it in a local folder somewhere. There are lots of files in the ZIP file, but the really important file is the YahooMap.swc file. Make sure you know the path to this file, you'll need it when you create your Flex project.

Then create a new Project in Flex Builder. You can define a Server Technology if needed, although for tinkering the first time you may want to keep the Project as simple as possible. In the 3rd screen in the New Flex Project wizard you can specify Source Paths and Library Paths. Select the "Library path" tab as you'll need to add the YahooMap.swc. Click the "Add SWC" button, and then browse to the YahooMap.swc file and click "OK". You should see the YahooMap.swc listed in the "Build path libraries" list. You can then finish creating the Project.

Now let's create the basic UI. This example will display the map in a large box on the right, and the left will contain simple text boxes, one to enter the map location, and the other to specify map searches. Here's the MXML code:

The code is pretty simple, and the only really interesting item is the <mx:UIComponent> which will be used to display the map. Paste this code into your app, and compile and run it, just to make sure all is working.

Next we'll add basic mapping. Here is the updated code:

Let's take a look at the above code. The big change is the <mx:Script> block. First come a series of import statements, and then two variables are defined. The first, appID, contains your Yahoo! Developer Network ID, replace the placeholder text in quotes with your own ID. The second defines the YahooMap itself.

The initApp() function (called on creationComplete) first creates a new YahooMap instance, and then defines the handler that will be called upon map initialization. It then initializes the map, passing the appID, along with the desired height and width (using the height and width of the mapUI UIComponent). Next a series of options are set, turning on panning, the scale bar, the map type widget, and the zoom control (you can omit these, or add other options if desired). And then finally, addChild() is used to add the yahooMap object to the mapUI UIComponent.

The code also contains two other functions. yahooMapInitialize() is called once the map is initialized (in response to a YahooMapEvent.MAP_INITIALIZE event). It sets the default zoom level and initial map location, and also specifies a resize handler. This is important, without a resize handler the displayed map would not resize if the app were resized. The resize handler function itself, yahooMapResize(), is called whenever the app is resized (in response to a ResizeEvent.RESIZE event), and it simply resets the map size (again using the height and width of the mapUI UIComponent).

You can paste this code into your app, and run it. You'll have a fully functioning map, allowing zooming and panning, and supporting multiple display types (Map, Satellite, and Hybrid).

Next we'll add code to allow users to enter a map location. Here's the updated code:

Not a lot of changes here. First, we've added some more needed import statements. We've also added a variable of type Address (to store the set map location). Two functions have been added to the code. setMapLocation() accepts a string (whatever the user typed in the txtLocation box) and then creates an Address object for the passed string. As you are probably noticing, the Yahoo! Maps component is used asynchronously and is thus highly event driven. setMapLocation() sets an event handler that will be called when the Address object has been successfully geocoded, and then it perform the geocode. The geocode operation does not do anything to the map, rather it locates matches and converts them into map locations. The event handler, yahooGeocodeSuccess(), first obtains any results generated by the geocode operation. It is possible for a geocode operation to return multiple results, but this code ignores all but the first match, and then uses that first match to set the map zoom level and location. And finally, setMapLocation() was added to the first <mx:TextInput> and <mx:Button> to the enter and click events respectively.

Save these changes, and then run the app. Now you can type in a country name, or a city and state, or a US zipcode, and the map will be repositioned to display the best match.

Now for the final change, this time allowing you to search for matches within the displayed map. Here's the code one last time: