Saturday, July 04, 2009    
Home My Books Blog ColdFusion About Me Back    

 • ColdFusion
 • Bookshelf
 • Tip-of-the-Day
 • CF ISP's
 • Who's Using CF?
 • CF Links
 • CF Tags
 • CF Resources
 • Mailing List


Sams Teach Yourself Microsoft SQL Server T-SQL In 10 Minutes

Join my mailing list and find out about new books and other topics of interest.

In response to popular request, here are some of my recent columns and presentations for your reading pleasure:

Columns
  • "But It's Free!" - ColdFusion Developer Journal (Vol 4 Issue 12) column - There was once a time, not that long ago, when I seemed to be spending a significant portion of my life explaining why ColdFusion was indeed worthy of consideration even though other products were free. Then I stopped hearing that objection for the most part, and life was good (well, better). But in the past two weeks I have had to defend ColdFusion against the "but [fill in the blank here] is free" objection no less than five times. So it looks like I need to address this issue one last time to clear the air and set the record straight.
  • A Cure for Arachnophobia - ColdFusion Developer Journal (Vol 4 Issue 1) column - Barely a week goes by without someone asking me about Cold-Fusion and search engine-friendly URLs. This is one of those topics that ColdFusion developers have been discussing for a long time - I first started a thread on this subject on the Allaire Developer's Forum close to five years ago. As this topic keeps coming up (and because three of you e-mailed me to ask about it this morning), I decided to scrap the column I was writing in favor of an explanation of all this once and for all.
  • Access Denied - ColdFusion Developer Journal (Vol 2 Issue 6) column on using file based databases (like Access) with ColdFusion. As a rule I try to avoid the Access/CF discussion as it inevitably provokes strong debate and even stronger emotions. Besides, the truth is - regardless of what I might suggest - Access remains an inexpensive and easily implemented solution. But I have come to realize that many users are considering only cost and performance in their decision-making process and are overlooking the bigger issues. So this column explains why production apps should never use file based databases.
  • And It Just Keeps Getting Better - ColdFusion Developer Journal (Vol 2 Issue 1) column on ColdFusion 4.5. ColdFusion 4.5 is a significant upgrade, don't let the half version number change fool you. This column discusses some of the new and exciting features in this new version of ColdFusion.
  • Be Extremely Graphic - ColdFusion Developer Journal (Vol 3 Issue 7) column - More ColdFusion applications are running on intranets and extranets than just about anywhere else. This is not surprising - as ColdFusion makes data access and reporting so simple it is a natural fit for applications in these environments. And, as such, data reporting is one area that ColdFusion 5 addresses head-on with the introduction of a true graphing engine.
  • Building a Better Custom Tag - ColdFusion Developer Journal (Vol 3 Issue 4) column - We've come a long way in the past couple of years. Not that long ago I was teaching how to write simple custom tags and encouraging developers to experiment with them. Now Allaire's Developers Exchange has thousands of custom tags listed, and I see developers using them as part of everyday development. Considering that it's been only a few years since Jeremy Allaire asked me to write a few tags so his new Tag Gallery would contain some initial content, we've made real progress. So now I'd like to up the ante a bit and challenge developers to build a better mousetrap (so to speak). Most of the newly available tags are new twists on old ideas, often the same old way of doing things. I'd like to see developers get creative with tag designs, making them as flexible and as reusable as possible. The better the tag design, the better the abstraction, the better the encapsulation, the better the interface - the more uses you'll find for it. That's really what custom tags are all about.
  • Caching in on Performance - ColdFusion Developer Journal (Vol 1 Issue 2) column on using caching to improve database response time. There's nothing that can kill your application's performance as quickly as database access. This is a shame, considering that almost every ColdFusion application you'll ever write will incorporate some sort of database integration. It thus follows that an important part of optimizing an application's performance is reducing its database activity. And no, this doesn't necessarily mean stripping out database access. The trick is to reduce the amount of database activity that your application generates. This is where caching comes in, as explained in this column.
  • ColdFusion and Java - A Match Made in E-Heaven - ColdFusion Developer Journal (Vol 2 Issue 4) column on ColdFusion and Java, and they can (and should) be used together.
  • ColdFusion and Java - More Than the Sum of Their Parts - ColdFusion Developer Journal (Vol 5 Issue 3) column - ColdFusion MX is fast approaching its first birthday, and what a first year this has been. A completely brand new ColdFusion, incredible new features and technologies, and even versions that run on J2EE servers on all sorts of platforms (including the oft requested Mac OSX). Which makes this a great time to review the ColdFusion-Java relationship, and what it means for you.
  • ColdFusion CFMX - A First Look - ColdFusion Developer Journal (Vol 4 Issue 5) column - It finally happened: the next-generation ColdFusion (previously code-named Neo) is in public beta, and is scheduled for a mid-2002 release. We (Macromedia and premerger Allaire) have been talking about this product for a long time, and we demonstrated it first publicly at DevCon 2001 in Orlando. As a rule, future products aren't discussed publicly in any detail (if at all), but ColdFusion MX is no ordinary product - indeed, it's as revolutionary a product as the original ColdFusion was close to seven years ago. So here, with special permission from the powers that be at Macromedia, it is my privilege to give you a first look at ColdFusion MX.
  • Data Entry ReFORMed - ColdFusion Developer Journal (Vol 4 Issue 11) column - HTML-based data entry is a pain, both for developers and for end users. There's no way to sugarcoat it, HTML forms as used today are pathetic. Sure, there are new form specifications on the way, but they are not yet in use, browsers don't support them, and they are still unproven entities. Luckily, there's an option available right now; it's called Macromedia Flash MX. This (longer than usual) column walks through the creation of ColdFusion powered Flash forms.
  • Database Support is Going to Get a Whole Lot Better - ColdFusion Developer Journal (Vol 3 Issue 3) column - At the Developer's Conference a few months back I was fortunate enough to introduce and first demonstrate the next major version of ColdFusion - CF5. However, time constraints prevented me from going into as much detail as I would have liked. As this issue of CFDJ is all about databases, I thought I'd take the opportunity to tell you about two very important and exciting database-related features that will make their debut in CF5.
  • Expect the Unexpected - ColdFusion Developer Journal (Vol 1 Issue 5) column on writing bug free code. No one wants to write buggy code, at least no one I choose to know. Bugs are annoying, bugs are embarrassing. And bugs can cost you (and your clients) lots of time and money. Bug free code is the ideal all developers strive for - at least should strive for - but it's a lofty goal not easily attained. To write bug free code it's important to understand how bugs are introduced, and this column delves into this topic from a ColdFusion perspective.
  • Faster and Safer Database Queries - ColdFusion Developer Journal (Vol 4 Issue 2) column - Databases and database access are fundamental elements of just about every ColdFusion application ever created. Database access makes applications real and live and dynamic and valuable, but it's also a major source of performance problems and a primary potential security target. In this article I discuss an oft overlooked tag, , designed to help address both potential problems.
  • Hidden Gems - ColdFusion Developer Journal (Vol 3 Issue 12) column - With all the talk and buzz surrounding Neo, it's important to keep in mind that ColdFusion 5 is still a relatively new product, one that many users have yet to take full advantage of. We're proud of ColdFusion 5, and rightfully so. It's the most reliable, most scalable, and most powerful ColdFusion yet, as well as the fastest server we've ever created. It's simply the best ColdFusion to date. Although I've dedicated numerous columns this year to ColdFusion 5, I thought it worthwhile to do it once more, this time concentrating on some of the little features and enhancements that many have overlooked - features and enhancements that truly are hidden gems.
  • How May I Be of Web Service? - ColdFusion Developer Journal (Vol 5 Issue 1) column - There is a phenomenon that appears to be unique to our industry - something I call buzzword du jour. On a regular basis a new buzzword (usually accompanied by a series of acronyms) appears on the front pages of the trade rags proclaiming to be "the future" - the message being "jump on board or become obsolete." This happens so frequently that many of us are becoming immune to it all, and in doing so are running the risk of missing something important when (or if) it happens. Which brings us to Web services.
  • Introducing Neo - ColdFusion Developer Journal (Vol 3 Issue 11) column - At last month's Developers' Conference in Orlando I was fortunate to be one of the first to demonstrate Neo, the next major version of ColdFusion. Macromedia (and earlier, Allaire) had been dropping little Neo-related tidbits for quite a while now - whetting our appetites with glimpses of what is to come. But as those of you who were in Orlando now know, Neo is exceeding all expectations. So for those of you who weren't there (don't make that mistake next year), and as a reminder for those who were, here are some of the highlights.
  • Introducing User Defined Functions - ColdFusion Developer Journal (Vol 3 Issue 5) column - Support for user-defined functions is easily the most requested and anticipated enhancement to the ColdFusion Markup Language (and the announcement of this feature at last year's Developer Conference was met with an applause that can only be called thunderous). In my last column I mentioned in passing that ColdFusion 5 would support user-defined functions (UDFs for short). With ColdFusion 5 just about out the door, I thought I'd take this opportunity to introduce you to UDFs - what they are, and how to write and use them.
  • It's All Very Personal - ColdFusion Developer Journal (Vol 2 Issue 5) column on personalization, the hottest trend in Web application development. For CF developers implementing basic personalization isn't difficult at all. In this month's column I explain what personalization is, why you should implement it and how to go about doing so.
  • Java for CFers - Part 1 of 3 - ColdFusion Developer Journal (Vol 2 Issue 11) column - Java is a reality. But for many CFers the buzz and hype surrounding Java is cause for much concern. For those of us who love ColdFusion because of its simplicity, Java can indeed seem intimidating. Much of that concern is legitimate. The fact of the matter is, there's no way you'll learn Java as quickly as you learned ColdFusion, and you'll definitely not be as productive as quickly. Having said that, Java does have lots to offer. It's fast, it scales well, it runs on a wide range of platforms, it supports all sorts of services and extensions. There's a seemingly endless supply of Java-related resources out there and - perhaps most important - Java is respected by the development community (considerably more so than ColdFusion is). And, as I've mentioned in previous columns, a Java/CF convergence of sorts is on the way (not that you'll have to learn Java, but you'll be able to leverage it if you so desire). In this column I start exploring Java (and JSP - JavaServer Pages - specifically) from a ColdFusion developer's perspective - and the best place to start is with some simple comparisons.
  • Java for CFers - Part 2 of 3 - ColdFusion Developer Journal (Vol 2 Issue 12) column - Continuation of a discussion of CF and Java. In the prior column I showed that server-side Java can actually be relatively painless. The trick is to use JSP - JavaServer Pages, a scripting-style interface that gives you access to all the benefits of Java without the pain. This column continues our look at JSP (using Allaire's JRun application server, which I strongly recommend that you download and play with).
  • Java for CFers - Part 3 of 3 - ColdFusion Developer Journal (Vol 3 Issue 1) column - Continuation of a discussion of CF and Java. In my last two columns we looked at JavaServer Pages (JSP) and compared ColdFusion development to JSP development. As explained, JSP is designed to dramatically lower the cost of entry into the Java development world, and JRun, in particular (with its tag libraries), does even more to deliver on this promise. In this column we look at options for using CF and Java together right now.
  • Just Your Type - ColdFusion Developer Journal (Vol 2 Issue 9) column on data types, and how to use them. ColdFusion features support for several different types of variables you can use in your applications...some types are simpler than others to use. When determining the type to use, simplicity and ease of use shouldn't be the only deciding factors. Use the wrong type...and performance can suffer.
  • Lock It or Lose It - ColdFusion Developer Journal (Vol 2 Issue 8) column on the all important issue of locking. We all know that locking is important. Most of us even understand why locks are needed. But exactly where to use a lock, which lock type to use and what code to put within the lock remains confusing at best. Part of the confusion stems from changes Allaire made in ColdFusion 4.5 that in turn changed the recommendations and suggested practices. Indeed, even my own recommendations changed with that release (as many of you CFUG members are quick to point out). And so, at the request of several of you, and because I've helped contribute to the confusion, this column explores this topic and tries to set the record straight.
  • Managing Stale Updates - ColdFusion Developer Journal (Vol 5 Issue 5) column - I receive lots of e-mail from lots of ColdFusion developers, and make every effort to respond to each and every one of them. Knowing the problems that ColdFusion developers are attempting to solve helps me know what topics to write and speak about. Indeed, the inspiration for most of my CFDJ columns comes from questions and comments from readers. So when I received two e-mails in one week asking about how to handle database locks when locks can't be used, well, the result is the column you are reading.
  • Maybe We Should Try a Seperation - ColdFusion Developer Journal (Vol 4 Issue 10) column - I have been writing and talking about ColdFusion components since before ColdFusion MX shipped. After I explained them in detail in two recent columns (CFDJ, Vol. 4, issues 6, 7), quite a few of you asked for practical examples of when and where they should be used. So, once again, let's take a look at CFCs, but this time from a very different angle - seperation of presentation and content.
  • No Strings Attached - ColdFusion Developer Journal (Vol 1 Issue 6) column on WAP - The Wireless Application Protocol. Wireless computing isn't a new concept. In fact, almost every year of this decade has been proclaimed as the year in which wireless will finally catch on. And each year has come and gone without that happening. Wireless computing, it seems, is always just beyond the scope of the mainstream. But all that is about to change. Wireless computing has finally come of age, and you, as a ColdFusion developer, are poised to take a leading role in wireless application development. This column explains what WAP is, and what it means for CF developers.
  • Preserve Precious Resources - Recycle - ColdFusion Developer Journal (Vol 2 Issue 2) column on code reuse. Learn how (and why) to work with includes, custom tags, and shared data.
  • Probe Your Servers - ColdFusion Developer Journal (Vol 3 Issue 9) column - For ColdFusion to work properly lots of bits and pieces have to be in place and functioning correctly. Web servers need to be up and running, database servers need to be accessible, any external components need to be reachable, and, of course, ColdFusion must be functioning properly. If any of these fail, so will your applications; if failure does occur, you need to know as quickly as possible, preferably before end users find out. Which brings us to the subject of probes.
  • Querying Queries - ColdFusion Developer Journal (Vol 3 Issue 6) column - This month I'd like to continue exploring ColdFusion 5 - this time concentrating on a radical new feature known as Query of Queries - a feature that lets you treat query results as if they were database tables.
  • Real Time = Real Problem - Most Web-based applications operate in real time. Add an article to a database and it shows up immediately on content pages. Update a user address and the new contact information is available immediately. Add or remove an employee and the phone directory is correct when next viewed. Real-time data in a real-time world. That's a good thing, isn't it? Maybe not.
  • Stick to the Script - ColdFusion Developer Journal (Vol 2 Issue 7) column on the tag. One of CFML's most misunderstood (and thus least used) features is the tag and its supporting scripting language. At the request of several readers this month's column explores this mysterious tag.
  • Take Your Database Out Of Retirement - ColdFusion Developer Journal (Vol 1 Issue 3) column on using databases effectively. Specifically, it takes a look at how databases should (and shouldn't) be used, and at database features that can be used to enhance application performance.
  • The Object of it All - ColdFusion Developer Journal (Vol 1 Issue 1) column on using COM objects within ColdFusion via the tag. Using the techniques discussed here you can use almost any ASP component with CF.
  • The Ten Commandments - Revisted - ColdFusion Developer Journal (Vol 2 Issue 10) column - It's been about five years since I inscribed my "Ten Commandments of ColdFusion Development" for my first ColdFusion book, and as Commandments should, they've remained the same (more or less) with each subsequent revision. Well, it had to happen. Unlike the other (and far more famous) Ten Commandments, mine were starting to stale and show signs of aging. So this month, in honor of the Second Annual Worldwide Allaire Developer Conference, I present to you "The New and Improved Ten Commandments of ColdFusion Development."
  • Tiers, Not Tears - ColdFusion Developer Journal (Vol 3 Issue 8) column - the basics of tiered applciation development are very applicable to ColdFusion development. At last year's Developer's Confer-ence I presented a session on creating n-tier (or multitier) applications in ColdFusion, explaining how tiered applications were more manageable and reusable. So why bring this up almost a year later? Well, a project I was working on recently forced me to revisit this topic, but this time for a whole new reason.
  • To Err Is Human, to Gracefully Handle Errors Is Divine - ColdFusion Developer Journal (Vol 4 Issue 3) column - Have you ever seen a ColdFusion error page - the bordered box on a white background that basically says someone (or something) messed up? I'm sure you have, as I'm sure your users have too. Errors, and error messages, are an unfortunate fact of development life. But while you may have to live with occasional errors, you definitely do not (and should not) have to live with that too-oft-seen CF error screen - that is neither professional nor secure.
  • Undocumented ColdFusion MX - 1 - ColdFusion Developer Journal (Vol 4 Issue 9) column - Discovering undocumented features in your favorite application is always something of a thrill. This is especially true when those features expose little nuggets of functionality that you can leverage in your own code. And so, as promised in my last column, I'm going to introduce you to the factory, a set of internal ColdFusion MX services exposed via Java objects and APIs.
  • Undocumented ColdFusion MX - 2 - ColdFusion Developer Journal (Vol 5 Issue 4) column - Several months ago I wrote a column entitled "Undocumented ColdFusion MX - 1". I appended a "1" to the title in anticipation of there being a "2" at some later date. Well, that time has come. That column (which apparently was highly controversial and upset quite a few readers, but fortunately made even more happy) exposed and explained the use of the ColdFusion factory object. This time we'll look at some of the configuration files used by ColdFusion MX - files that can be tweaked as needed (and no controversy this time, I think).
  • User Defined Functions - Round 2 - ColdFusion Developer Journal (Vol 4 Issue 8) column - The introduction of user-defined functions (UDFs for short) was the most requested and anticipated event in the ColdFusion 5 era - developers desperately wanted to be able to extend CFML, using not just tags, but functions as well. I first introduced UDFs a year or so ago (CFDJ, Vol. 3, issue 5), but now it's time to revisit the subject. Why? Because ColdFusion MX provides us with a whole new way to write UDFs, this time using tags.
  • Using ColdFusion Components (Part 1) - ColdFusion Developer Journal (Vol 4 Issue 6) column - In the May issue of CFDJ (Vol. 4, issue 5) I introduced you to ColdFusion MX - the just-released ColdFusion upgrade that is nothing short of revolutionary. As I explained in that article, CFMX features lots of incredible new technologies and features. But the one I think is most important (in terms of how it will, or should, impact your development) has to be ColdFusion Components. This month (and continued next month) I'd like to explain in depth what CFCs are and how they should be used.
  • Using ColdFusion Components - Part 2 - ColdFusion Developer Journal (Vol 4 Issue 7) column - Last month I introduced you to ColdFusion Components - CFCs for short. Following a brief introduction to the world of objects, we looked at CFCs and their syntax, and simple calling conventions using . This month we'll continue this topic.
  • WAP Revisited - ColdFusion Developer Journal (Vol 3 Issue 2) column - Fourteen columns ago in CFDJ (Vol. 1, issue 6) I wrote about wireless computing having finally come of age, the importance of WAP, and that ColdFusion developers could leverage this new and exciting technology quickly and easily. In this month's column I'd like to revisit WAP, but not from a beginner's perspective (for that, refer to my aforementioned column). Rather (based on the questions I get asked most frequently), I'd like to take a big step back and look at some overall design and development considerations - things to keep in mind when looking at WAP.
  • When NOT to Use ColdFusion - ColdFusion Developer Journal (Vol 2 Issue 3) column on how to correctly use (and not use) ColdFusion. Yes, you read the title correctly, and no, I'm not losing it. I really do believe there are times when you should not use ColdFusion. In this column I tell all.
  • Where To Go From Here - ColdFusion Developer Journal (Vol 3 Issue 10) column - ColdFusion 5 is a great product, so much so that I've dedicated six of my last seven columns to introducing and analyzing its new features and technologies. ColdFusion 5 is mature, fast, reliable, and robust, and with its release Macromedia has demonstrated a definite commitment to CF and the former Allaire community. And the community acknowledges this. But, ColdFusion is not enough.
  • Which Is Faster? - ColdFusion Developer Journal (Vol 5 Issue 2) column - Which is faster, or ? Which is faster, CFML or ? Which is faster... ? If you're a ColdFusion developer, chances are that you've asked (or have been asked) these questions and others like them.
  • Yes, YES, it CAN Scale - ColdFusion Developer Journal (Vol 1 Issue 4) column on ColdFusion and scalability. Barely a day goes by without someone wanting me to reassure them that ColdFusion scales. Whether it's Web administrators who are experiencing poor application performance, partners who want to be sure ColdFusion can handle their anticipated load, developers whose bosses are threatening their jobs over failed deployments, or press and analysts positioning ColdFusion as a "low-end solution." Whichever it is, inevitably I end up in the position of defending ColdFusion and its scalability. In this column I explain why I think this perception exists, and how to respond to it.
  • Articles
  • Extending ColdFusion Studio - We all know and dearly love ColdFusion Studio (and its little brother HomeSite). We all have favorite features, we all have our own little tips, tricks, and settings, and we all find ways to make it work as suits as best. But what many of us don't know is just how extensible and configurable ColdFusion Studio really is. And so in this article I'd like to introduce you to one of the ways to extend this product — Tag Editors.
  • Macromedia Flash MX Data Connection Kit - Powered by ColdFusion - Macromedia recently released Macromedia Flash MX Data Connection Kit, a Macromedia Flash MX add-on designed to simplify building rich data front ends in Macromedia Flash. To introduce you to the new Data Connection Kit, and to jump-start using this new tool, build a complete application with me—using ColdFusion MX on the back end and the Data Connection Kit on the front end.
  • Making WAP and ColdFusion Play Nicely Together - ColdFusion is becoming a popular server for powering WAP applications. There are many reasons for this, starting with the fact that it's cross-platform and client-independent, has a massive installed base, and dominates in intranets and extranets (which is also where WAP has gained significant momentum). The single most important reason for ColdFusion's popularity as a WAP back end is that it's so easy to learn and use. The CFML language is tag-based (much like WML), so developers comfortable writing WML feel comfortable with CFML in no time at all (and vice versa). ColdFusion does have its roots in the Web, and while it is indeed client-independent, there are some gotchas that WAP developers need to pay special attention to.
  • On Using XML (Dynamic XML Menus) - Not long ago, I started every presentation on XML explaining that it was not a new page markup language and that it did not in and of itself replace HTML. Fortunately, we've made some progress of late–developers now understand that XML is nothing more than a data sharing mechanism–simple as that. What makes XML exciting is that it makes sharing data safe and very portable–and that's it. In other words, while you wouldn’t format web pages in XML, you may definitely store content in XML, especially when different systems need to share, access, or manipulate content. But manipulating XML data is not trivial, unless you are using Macromedia ColdFusion MX. ColdFusion MX has built-in support for manipulating XML, and in true form, manipulating CFML-based XML is anything but complex. This means that ColdFusion developers can choose XML as a very real and very viable option for storing and sharing data.
  • To # Or Not To # - Cold Fusion developers all use pound signs (the # character). It's close to impossible to write CF code without them, so much so that I am beginning to wish that someone would create a keyboard with a standalone # key on it. But most CF developers overuse these little characters, more often than not purely out of misunderstanding. Hopefully by the time you finish reading this article I wrote for Defusion magazine you won't be one of them.
  • Use ColdFusion Components - Properly - Code reuse is good. It's such a good thing, in fact, that Macromedia ColdFusion lets you reuse code in several ways, from simple includes to custom tags and user-defined functions. Over the past few years, ColdFusion developers have come to understand what these methods are and the better developers out there made a point of taking advantage of code reuse so they could build better applications. And then, just when everything was clear and well understood, things got a little more complicated. ColdFusion components (CFCs) are the new application building blocks introduced in Macromedia ColdFusion MX. They do the seemingly impossible—marrying the power of objects with the simplicity of CFML.
  • WAP Powered by ColdFusion - ColdFusion is an ideal development platform for WAP applications as explained in this primer written for wuzap.org. From basic CF powered WAP, to dynamic cards and decks, to working with WAP input fields, this article will help you get started with CF powered WAP.
  • E-Learning
  • ColdFusion MX User Defined Functions - User Defined Functions (UDF's) were first introduced in ColdFusion 5. ColdFusion MX provides a whole new way to create UDF's making the process both simpler and far more powerful. In this lesson you'll learn what UDF's are and how to write them in ColdFusion MX.
  • Preparing for ColdFusion MX - ColdFusion MX, the product formerly known as "Neo", is here. This major upgrade to ColdFusion is the most significant since the products creation seven years ago, and you should plan on migrating to ColdFusion MX immediately. In this lesson you'll learn key points that will make your upgrade and migration as simple as possible.
  • Using Web Services - Web Services are all the rage right now, and ColdFusion MX makes Web services incredibly usable. In this lesson you'll learn what Web services are, how they work, and how you can take advantage of this exciting new technology.
  • Miscellaneous
  • Colorado Macromedia Technology Conference w3w3 Interview - w3w3.com radio interviewed me at the Denver Convention Center, on March 15, 2002, asking all about Allaire, Macromedia, and the MX products.
  • Creating Custom Tags - Allaire Alive title on creating ColdFusion Custom Tags. Flash based presentation (6:00 minutes)
  • Macromedia DevCon 2001 - Day 1 General Session - You should have been at DevCon 2001 in Orlando, but if not, here's your chance to experience Monday's General Session for yourself. Listen to Macromedia folks (including Kevin Lynch, Jeremy Allaire, and myself) talk about the future of Internet applications, demonstrate new products, and explain the strategy for the next generation of ColdFusion (including the very first public demo of "Neo" - the next major version of ColdFusion).
  • Understanding Wireless Applications - Allaire Alive title on ColdFusion and the world of wireless applciations. Flash based presentation (12:44 minutes).
  • WAP Q & A with Allaire's Ben Forta - Transcript of an Allaire interview on WAP, it's potential, and what it all means for ColdFusion developers.
  • Presentations
  • CF5 UDF's (User Defined Functions) - User Defined Functions (UDF's) are one of the most exciting and eagerly anticipated new feature in ColdFusion 5. This presentation, created for my CF Rocks CFUG Tour, explains UDF's from the ground-up - starting with basics and syntax, and going all the way through more obscure and complex examples. Everything you ever wanted to know about UDF's, and then some.
  • ColdFusion 5 - What's New? - ColdFusion 5 is the best ColdFusion ever - a version of ColdFusion built specifically to address developer's issues and requirements. This presentation, an adaptation of one used for the CF5 launch as well as my ColdFusion Rocks tour in 2001, lists the major (and not so major) reasons to upgrade to ColdFusion 5 now.
  • ColdFusion MX for J2EE - The Marriage of Power and Productivity - 25 minutes Breeze presentation on ColdFusion for J2EE. This is a technical presentation using slides and audio narration.
  • ColdFusion Security Essentials - Slides from presentation on ColdFusion security, covering admin settings, coding, and more.
  • Introducing A Better - is the most used Internet protocol tag in CFML, and has been dramatically enhanced in ColdFusion MX 6.1.
  • The Wireless Revolution - WAP is hot technology, and one that ColdFusion and Spectra developers can leverage with ease. Learn all about WAP, what it is, and how to use it.
  • Tips & Tricks of the ColdFusion Masters - One of my most popular CFUG presentations, and one that keeps evolving based on user feedback. Learn the do's and don'ts of optimizing and scaling ColdFusion applications. This is a long presentation (the last few times I presented it took over two hours each).
  • Undocumented ColdFusion MX 6.1 - FlashPaper version of the "Undocumented ColdFusion MX 6.1" presentation used in user group presentations. This presentation keeps evolving, each time I find something new of interest to include I do so (the last update date is on the title page). If you have any additional tips, or find that any of these are incorrect or no longer work, let me know.
  • When One ColdFusion is Not Enough - Multiple ColdFusion instances, how and why this is so important.
  •   © Copyright 1997-2009 Ben Forta, All Rights Reserved