Full Blown Web Design

Benefits of a ColdFusion Website

Sat, 05 Jul 2008 00:26:08 PST

ColdFusion websites deliver richer and more powerful applications.
Websites written in ColdFusion delivers higher levels of productivity and efficiency.
ColdFusion websites are easier to maintain than static websites.
ColdFusion websites offer highly approachable integration with all major Internet standards and component models.
ColdFusion websites can be run on any of the leading server operating systems.
ColdFusion will deliver a site in any language.
ColdFusion gives us flexibility and allows you to create customised functions i.e. currency conversion.
ColdFusion offers increased levels of accessibility: easy to build websites for those who are visually impaired or who have other disabilities.
Websites written in ColdFusion enables the production of professional business graphics .
Developers proficient in ColdFusion can build more advanced sites.

Who's using ColdFusion?

Wed, 02 Jul 2008 00:26:08 PST

192.com
ACD Direct
Allied Office Products
America First Credit Union
American Power Conversion
Amkor Technology
Aspen Skiing Company
AT&T Wireless
Bank of America
Bertelsmann
BMW USA
Boeing
Casio USA
Caterpillar
Chicago Bears
City of Davis, California
County of San Diego, Department of Child Support Services
Crayola
Dallas Stars
DHL
Dial Corporation
East Carolina University
eBags
Eli Lilly
eMCSaatchi
FAO Schwarz
First Union
Foot Locker
George Washington University
Georgetown University
GlobalSpec.com
Goodyear
Half.com
Hasbro
iHotelier
Inmarkets Training, Ltd.
International Speedway Corporation
InvestEdge
Jaguar Australia
Legato
The Limited
Mayo Clinic
Mayo Health Systems
Michelin
Moen
MySwitzerland.com
NASA Goddard Space Flight Center
New York Giants
New Era Cap Company
New York State Office for Technology
One World Alliance
Peace Corps
Pepsi
PGA of America
Pottery Barn
Prometheus
Quaker Oats
Roche Pharmaceuticals
Rugby Football Union
Schlumberger
Scott's Corporation
Seattle Times
United States Senate
Siemens
Simon & Schuster
SmartMoney.com
Sprint
State of New York
Symantec
Travelers
United States Olympic Committee
US Bank
The Wharton School of the University of Pennsylvania

The Power of Coldfusion for your Intranet

Tue, 01 Jul 2008 00:26:08 PST

Upon choosing to work for my current employer I was told, "We have a corporate intranet that many Fortune 500 companies would be envious of." I have to admit, I was a little bit skeptical. However, it wasn't long until I realized how impressive this intranet really is. Because it's powered by Allaire's ColdFusion, our developers have been able to launch sophisticated new applications in a matter of weeks. These custom-built applications address the specific needs of our business, so we don't waste time trying to adapt to generic software. Best of all, our intranet is easy use because everything works inside my Web browser.

It's no surprise that Web-based intranets have become more common. The web is an inviting venue for an intranet. Most employees use the internet regularly and can proficiently navigate in a Web browser. With the use of ColdFusion, the Web can become a functional environment custom to a company's unique needs.

ColdFusion is a development environment that facilitates dynamic, database-powered html page generation. Its core benefits can be illustrated with an example of one organization's need for a company directory system. The system needed to be web-based to ease accessibility to telecommuting employees, clients, and business partners.

A static approach to this project would require programming of html pages for each employee and tedious programming of a menu page to each employee record. Changes that effected several employees, such as management or location, could require hours of editing affected employees records.

With ColdFusion, new employees will fill out a Web-based form. Once the "submit" button is clicked the employee's information is stored to a database. Employee records can be accessed through a Web-based search utility. Employees can be marked inactive with a click of a mouse. Management changes only require one correction, rather than several.

The dynamic approach obviously makes managing the company directory system easier and more efficient. The benefits don't end there. The same employee record created for the company directory can also be integrated into an employee time clock, payroll system, or project management system. Due to ColdFusion's flexible security parameters, it is possible to give employees limited access to their employee record to update their home address, personal email address and other information while maintaining limited access.

It is possible to use other programming languages to create a Web-based intranet. However, ColdFusion remains the ideal environment for several reasons. ColdFusion was initially created for the Web and is therefore more efficient and more intuitive than either ASP or PHP, which were derived from Visual Basic and Java respectively. Furthermore, ColdFusion's inherent similarity to html makes it easier for Web developers to learn.

Another edge that ColdFusion has over its competitors is the potential speed of development. Allaire designed ColdFusion to facilitate RAD (Rapid Application Development). So, ColdFusion applications specific to a unique business process can be developed relatively quickly and inexpensively.

ColdFusion is extremely versatile in a number of respects. Its modular, template driven nature allows integration of Web-based applications that are not ColdFusion based. Also, ColdFusion is flexible in that it is compatible with a variety of database types, such as Oracle, MS-SQL, Postgre, Access, and others.

It can be used to create useful applications for any department. It has commonly been used for human resource systems, sales automation and customer relationship management.

ColdFusion can also be used to create corporate-wide communication tools. Examples include message board systems, online suggestion boxes and web newsletter systems. All employees could benefit from time management tools such as a scheduling system or a task manager system. Security options can be set so that certain features can be accessed at any computer (home, office, or on the road) for added convenience.

ColdFusion's ability to tie into mail servers opens up another realm of communication possibilities. It's possible to implement web-based email, individual email, workflow notification or batch-email capabilities.

The potential uses of ColdFusion are endless. It serves as a practical development environment due to its flexible nature, ease-of-use and expandability. Such benefits make ColdFusion an ideal intranet development environment for companies of any size.

Why use Coldfusion?

Mon, 30 Jun 2008 00:26:08 PST

When I was first introduced to ColdFusion, I was against it. It was version 5.x at this point, and I couldn't see anything about it that I liked. My counterpart on the East Coast had been using it for years and was a seasoned ColdFusion programmer. I was a seasoned PHP programmer who had just completed a major project for my department, and was now being asked to move to ColdFusion to come into line with worldwide operations. I was a rogue developer with my FreeBSD PHP Web server and I didn't fit with the Microsoft world I was working in.

My company sent me to the East Coast to talk to this developer and to learn more about ColdFusion and why it would be a good move for us. Of course, I was skeptical; ColdFusion was a rich man's language in my eyes. With the server costing $1,300 or more, not including the cost of MS Windows, etc., I couldn't see how my little section could afford to make the leap. I spent a week on the East Coast shadowing this ColdFusion programmer, and when I left to come home, I had a stack of ColdFusion books and a new respect for the language.

Many of you, I'm sure, have at some point had to look at an alternative language for Web development. It's not easy to move from a language you know, love, and have spent months or years mastering, to one that seems completely foreign. This is what faced me when I was asked to switch from my happy PHP world to the dark side of ColdFusion.

Just over two years later, I'm a 100% ColdFusion shop. Sure, I still talk about PHP, and I still recommend it here and there, but I've learned that I can do things faster, cleaner, and -- believe it or not – more cheaply than I could with PHP. You might be skeptical now, as I once was, but I hope that by the end of this article, you'll start to see enough of the light to realize ColdFusion isn't the dark side after all.

Background

First, some background on the ColdFusion language for those who are totally in the dark about it.

ColdFusion was originally developed by the Allaire brothers in 1995. This then started the Allaire Company, which was later bought by Macromedia. Like most Web languages, it was meant to provide Web developers with a way to talk to a database and display data on Web pages. As with many such languages, in the early days, it was not the most advanced technology, but it was one of the more simplistic to implement, understand and use. This vision still holds true with today's ColdFusion MX (version 6.x of ColdFusion). In fact, ColdFusion was the reason Microsoft released ASP, which was being developed by Aspect Software, a competitor of Allaire that was later bought by Microsoft. So, in a round about way, all you ASP programmers have the ColdFusion developers to thank for your programming language!

Now, let's get back to the background of the ColdFusion language. Besides a history of acquisitions and changes, ColdFusion has always been a Rapid Application Development (RAD) language built for the Web. ColdFusion accomplishes this RAD claim by providing the language in a tag-based usage, which will be familiar to any HTML programmers.

Many of the other languages out there use a programmatic approach to server side scripting, which is great for a seasoned programmer, but, to someone who's spent most of their time with HTML tags, this can be a little daunting. A ColdFusion tag always looks like <cfTagName> with the "TagName" being replaced with the actual tag you are using. Similar to the way PHP uses the <?php and ASP uses <% to signify the start of code, the <cf tells the ColdFusion server, "Hey, here's some ColdFusion to process".

Most ColdFusion tags have an ending tag that makes up a tag pair. Like HTML tags, CF tags end with </cfTagName>. So, for example, you could use the following code:

<cfloop index="i" from="1" to="10"> <cfoutput>#i#<br /></cfoutput> </cfloop>

Both the <cfloop> and <cfoutput> tags are the starting tags; the </cfloop> and </cfoutput> are there respective ending tags. As you can see from the above example, you can have code between tags, and you can even nest tags if your application so needs them.

You've just seen a very short snippet of ColdFusion code. It's not my intention to teach you ColdFusion here, but to provide you with enough knowledge to make you curious to check it out further. To learn more about ColdFusion tags, aka ColdFusion Markup Language (CFML), visit the Macromedia Website or browse many of the fine articles here at SitePoint.

ColdFusion Myths Debunked

You now have some very basic background information on the history of ColdFusion and how its tag-based language works. But, I'm sure you are not sold on ColdFusion yet -- in fact, you're probably thinking much like I was as this point. Let's dive into some of the myths and misconceptions about ColdFusion, so we can clear the air a bit.

Myth #1: ColdFusion is a Rich Man's Language

False! Yes, if you go to Macromedia's Website and look up the ColdFusion server, you'll see a sticker price of $1300 for the standard edition, and if you head over to Zend's Website you can purchase their PHP Performance Suite for around $1875. I know you don't need the Performance Suite to run PHP applications, but the Performance Suite gives you "Dynamic content caching, Code acceleration and File compression technologies, as a single solution", which is what the Macromedia ColdFusion server gives you out of the box.

This is a good time to point out that Macromedia doesn't charge for development servers, just for the actual production server. So, what happens when you go to production? Well, if your group has the budget, you can purchase the Macromedia Standard or Enterprise versions, or you can opt for a free version of the ColdFusion server. Besides the developer edition, download any Macromedia ColdFusion server and, after 30 days, it becomes a full-featured developer edition.

A company named New Atlanta has its own version of the ColdFusion Server. This ColdFusion server is called Blue Dragon and it comes in 3 flavors, just like Macromedia's servers. New Atlanta has a Server Edition, a Server JX version and a J2EE version, while Macromedia has Standard, Enterprise and Enterprise J2EE versions. The great thing about the New Atlanta Server version is that it's currently free, and there are no signs of this changing any time soon. Why is it free? It doesn't have all the CFML tags you'd get in the New Atlanta JX version or the Macromedia Standard Edition.

I've worked on the New Atlanta free server and I can tell you, it's great. It does place some limitations on the tags you can use, and the kinds of databases you can connect to (it's currently limited to MySQL, PostGreSQL or ODBC via ODBC / JDBC Bridge), but none of this is really going to impact on your development -- most of the missing tags are Macromedia-specific. Performance-wise it was really hard for me to tell a difference, though it will probably vary from application to application, and server to server.

The New Atlanta product does offer budding ColdFusion programmers the ability to deploy applications with little cost to the end users. You can even bundle the New Atlanta server with your application and deploy it all at once (special licensing is needed to accomplish this). So, ColdFusion is no longer just for the rich. New Atlanta has brought it to the masses.

Myth #2: ColdFusion is Slow

False! ColdFusion is very fast, even for someone who is just starting out and hasn't learned all the tricks.

Currently, ColdFusion MX is built using Java (in the past, it was developed on C++), and when your pages are run for the first time, they are compiled into Java bytecode. In layman's terms, your ColdFusion pages are compiled when they are first run, much like a program, and are then stored on the ColdFusion Server as binary files. If your ColdFusion server is configured with Trusted Cache turned on, then your files will be compiled only once. If Trusted Cache is turned off, your files are compiled with each page load, or when the page expires (again, a discussion of the CFML code and server configuration details to do this are beyond the scope of this article).

So, what's so special about the pages being compiled into bytecode?

Bytecode is computer object code that is processed by a program, usually referred to as a virtual machine, rather than by the "real" computer machine, the hardware processor.

(Definition from Whatis.com)

Once the ColdFusion code is compiled into bytecode, your server can interpret the instructions of your program faster, since it's in a language it already understands. Many current Web languages are interpreted at runtime, which means that they're processed and compiled each time they're run. Typically, the difference between bytecode and interpreted code on a Web page is milliseconds to seconds. Yet, these differences can add up quickly in a Web application, and could easily mean the difference between a happy customer and an unsatisfied customer.

Myth #3: ColdFusion isn't supported the way <insert language> is!

Wrong again! ColdFusion has a huge community of followers and is backed by one of the largest Internet companies. You can find loyal ColdFusion followers in just about every major city across the world. They typically belong to the local ColdFusion User Group (CFUG), and are always willing to lend a hand or some teaching to help you along the way. There are also ColdFusion communities springing up all over the place.

Believe the Hype: Coldfusion 8 has arrived

Sun, 29 Jun 2008 00:26:08 PST

ColdFusion continues to thrive, even more so under the auspices of its new owner, Adobe. With the release of ColdFusion 8, Adobe has reaffirmed its commitment to ColdFusion by releasing the most feature-rich version in years.

Whether you've never used ColdFusion before, you're considering coming back to the fold, or you're looking for a good reason to upgrade, ColdFusion 8 definitely deserves your consideration. Indeed, ColdFusion 8 represents a major release, with more new features than I could possibly cover in a single article. In short, now is a very good time to be a ColdFusion developer, and in this article we'll look at my favorite reasons why.

Speed Improvements

What's that you say? Speed is not a feature? Well, when the improvement is as dramatic as it is in ColdFusion 8, it can definitely be considered a feature. The ColdFusion team analyzed over 100 actual customer applications to find and eliminate bottlenecks. This resulted in an overall improvement that makes the server up to 4.25 times faster than ColdFusion 7.0.2. In fact, some specific areas and tags are 39 times faster than prior versions. In particular, if you're undertaking object-oriented development using ColdFusion components (CFC), you'll notice a marked improvement.

The best part is that you don't need to do anything to take advantage of this feature other than install ColdFusion 8. Without changing a single line of code, your existing ColdFusion application will see a huge performance boost. So, here's the plan...

Sell your boss on a plan to dramatically improve site performance, budgeting four weeks of work.
Buy and install ColdFusion 8.
Spend four weeks improving your ranking on World of Warcraft.

If you aren't already developing with ColdFusion, it's important to keep in mind that ColdFusion has long since outgrown the accusations of being slow or unscalable. As a developer at The Economist who recently upgraded to ColdFusion 8 noted, "...the whole thing is ridiculously stable."

Server Monitor

Sometimes, when diagnosing application performance issues in previous versions of ColdFusion, it felt like you were a doctor trying to diagnose an internal injury without access to an x-ray machine. You knew something was generally wrong inside, but you had no way of seeing (and therefore, of treating) the issue. Well, the good news is that ColdFusion 8 (Enterprise and Developer versions) comes with an x-ray machine ... er ... a server monitor that allows you to peer at the internals of your ColdFusion server on which you're running your application.

The ColdFusion Server Monitor is a Flex application that allows you to examine a variety of statistics related to the overall health of your server. It provides you with details about specific applications, sessions, requests, and queries. For example, you can get reports on slow requests, and drill-down into those requests to see variable memory usage for each request, as well as the performance of any includes, custom tags, and components within the request. This can help immensely when you're trying to locate bottlenecks within a slow request. In my opinion, this feature alone will have a huge impact on how developers will build and debug ColdFusion applications going forward.

In addition, the Server Monitor offers customizable alerts that allow you to receive notification when certain undesirable behaviors occur, such as low JVM memory or excessively long-running threads. You can even customize the response that the Server Monitor implements when this behavior occurs, configuring it either to send an email, create a snapshot, kill threads running longer than a specific timeframe, or even execute a set of custom code from within a ColdFusion component that you specify.

Ajax Integration

With the release of version 7.0.2, ColdFusion added Flex integration, which made it the language of choice for building Rich Internet Applications (RIAs) using Adobe's Flex. This was great for those of us who love Flex (as I do!). However, building RIAs with Ajax required the integration third-party open-source libraries if you wanted to work natively with ColdFusion data types and JavaScript. It also meant that you had to include and learn the syntax of one or more external JavaScript libraries like Ext, Spry or the Yahoo User Interface library (YUI). With ColdFusion 8, this is no longer the case.

ColdFusion 8 has added a long list of new tags and features that have been designed specifically to allow you to rapidly build Ajax-based Rich Internet Applications using a comfortable and familiar tag and function syntax. In fact, the libraries that I mentioned above are built into ColdFusion 8, making it possible, for example, to create an Ajax grid using Ext simply by using the cfgrid tag. You can even bind this grid to a dataset that's returned by a CFC method simply by putting a reference to the cffunction into the bind attribute of the tag. ColdFusion 8 really does make it incredibly simple and intuitive to add some glitz to your application by integrating rich user interface elements.

Even better, in my opinion, is that the Ajax integration in ColdFusion 8 goes much deeper than simply adding fancy UI elements to your application. ColdFusion added tags and functions that allow you to easily move data back and forth between JavaScript. For example, with the cfajaxproxy tag you can make functions that reside within a CFC callable directly from your page, using JavaScript. This feature will even automatically convert data types (such as a ColdFusion query object) into a type that's usable within your JavaScript block, such as an array or as JSON packets. The created proxy also contains built-in methods for setting a callback handler for the asynchronous method calls. All of this makes working with Ajax and ColdFusion feel completely seamless.

The following example code shows how the cfajaxproxy tag can be used to create a class based upon a component that can be used within JavaScript:

<cfajaxproxy cfc="path.to.cfc" jsclassname="MyClass" />
<script>
function myFunction(id) {
var myClass = new MyClass();
myClass.setCallbackHandler(populateWindow);
myClass.getSomeData(id);
}
function populateWindow {
// this function can be used, for example, to populate the returned data into a javascript window generated with the cfwindow tag
}
</script>

Debugger

A long time ago, ColdFusion had its own IDE called ColdFusion Studio, which included a step debugger. When that tool moved on from this world, ColdFusion programmers became experts at trying to debug through the cfdump/cfabort method, which basically entailed dumping the value of a variable on-screen and aborting the request. While this was effective, it has some major drawbacks, the primary one being that it was an extremely slow and tedious process to debug an entire page this way. Nonetheless, many ColdFusion programmers like me grew accustomed to the drudgery and forgot what we were missing ... Well, we're without a serious debugger no longer!

The ColdFusion 8 debugger was built in the Eclipse IDE, which is a tool that will be familiar to anyone using either Flex Builder or CFEclipse. The debugger allows you to set breakpoints and to debug requests running on either a local or remote ColdFusion instance. Once a breakpoint is encountered, you can inspect the value of any and all variables within any scope contained in the request. Additionally, you can step through the request and watch certain expressions to look for inconsistencies in the value settings. I believe this, combined with the Server Monitor, not only makes the debugging process much easier, but allows us the insight to create much more efficient and bug-free applications. Not that I ever write bugs! (Ahem! -- Editor.)

Multi-threading

I liken the addition of multi-thread capabilities to ColdFusion 8 to being bitten by a radioactive spider. It provides the developer with a great deal of power, but we all know what comes with great power ... yes, usually fame and money, but in this case I'm referring to great responsibility. Additional threads are used to improve the performance of a request that contains some sort of long-running process which is passed off to a thread. Typically, threads can either be:

created and then rejoined to the current request thread when they have completed
created and then simply forgotten about when they have completed
created and run indefinitely, being alternatively put to sleep or put to work as needed

ColdFusion makes it very easy to spawn new threads with the cfthread tag. Any code contained within the cfthread tag is executed asynchronously, with the current request existing in an independent stream of code execution. The remainder of your request can continue to process without the need to wait for the thread's code to finish unless it's instructed to do so. Any experienced programmer will have run into a multitude of situations where the page request shouldn't need to wait for a particular process to run before continuing, so clearly this is a very useful function (despite its propensity to be misused).

To give you an example of how this would work, the following example shows some code that loops through an array of RSS feed URLs and uses the new cffeed tag to parse the RSS XML. It processes each feed on a separate thread so that they can all run simultaneously, reducing the overall time it takes to process the page. Once the threads are complete, another cfthread tag is used to rejoin them to the current thread, where we can output the values. Those of you who are already familiar with ColdFusion might also notice that I'm using the new implicit array creation to build my feed array:

<cfset feeds = ["http://www.remotesynthesis.com/blog/rss.cfm?mode=full","http://www.nytimes.com/services/xml/rss/nyt/HomePage.xml"] />
<cfset threads = "" />
<cfloop from="1" to="#arrayLen(feeds)#" index="i">
<cfset threads = listAppend(threads,"thread"&i) />
<cfthread action="run" name="thread#i#" feed="#feeds[i]#">
<cffeed source="#feed#" properties="thread.myProps" query="thread.myQuery" />
</cfthread>
</cfloop>
<cfthread action="join" name="#threads#" timeout="6000" />
<cfloop list="#threads#" index="thread">
<cfif structKeyExists(cfthread[thread],"myProps")>
<cfoutput>#cfthread[thread].myProps.title#<br/></cfoutput>
</cfif>
</cfloop>

Even More...

As I said earlier, there are so many new features in ColdFusion 8 that I can't possibly cover them all in detail here. However, here's a handful of the key features that might pique your interest in this new release:

Deeper PDF Integration: As one would expect from an Adobe product, ColdFusion 8 contains the most sophisticated PDF integration of any application server. It goes beyond simply creating PDFs on-the-fly to proving developers with the ability to create PDF forms and accept PDF form submissions, merge PDF files, add and remove pages, create page thumbnails, and much more.
RSS/Atom Integration: As shown briefly above, the new cffeed tag makes it easy to read and create RSS or Atom feeds.
Image Manipulation: ColdFusion 8 finally includes a long list of tags and functions to create and manipulate images.
Zip/Jar File Manipulation: Create, modify and extract both .zip and .jar files.
Presentations on Demand: Build on-the-fly presentations that work just like Adobe Presenter.
Language Improvements: Version 8 introduces a number of syntax and general language enhancements that include JavaScript-style operators, implicit array and structure creation, and the passing of attributes into tags as collections. These improvements can make your code faster to write, easier to read, and much less verbose.
.Net Integration: Work natively with .Net assemblies that exist either locally or on a remote server.
Exchange Server Integration: Programmatically manage email, calendar items, contacts, and tasks on a Microsoft Exchange Server via ColdFusion tags.

Summary

As you can see, so many new features are included in ColdFusion 8 that your five favorites might be entirely different from mine. If you haven't tried ColdFusion 8 yet, what's stopping you? The Developer Version is free, after all. Give it a go!