ColdFusion, from Allaire, provides an application development platform suitable for network software. Although it's not as glamorous as, say, cold fusion nuclear energy, ColdFusion does include some exciting technology in its own right.

In a nutshell, ColdFusion provides components that enable the creation of dynamic, database-powered Web applications. By "Web applications," I mean software applications and services built with Web technologies -- both public Internet and intranet software. Examples of potential ColdFusion Applications on the intranet in particular include business process automation, training, content management, and bulletin board conferencing. On the Internet, ColdFusion can play a role in ecommerce sites just to name one example.

ColdFusion possesses a number of features that make it potentially appealing for Web development. It offers a high-level programming model not drastically different from the HTML files and editors that many Webmasters already know. It has been designed to allow for the integration of custom modules -- important for organizations looking to tailor software to fit their specific needs. And it supports connectivity to databases.

Read More :-
http://compnetworking.about.com/od/softwareapplicationstools/l/aa021100a.htm



Visit Our
ColdFusion Development Services.

When trying to judge expected behavior from potentially problematic behavior, looking at memory behavior often is a place ColdFusion Administrators will start.

Even though the standard amount of RAM continues to increase, a close examination of an application's use of system memory remains a critical part of the Q&A process.

Fortunately for the developer, a variety of memory tracking abilities exist to troubleshoot an application's use of system memory. Unfortunately for the developer, the multitude of metrics to choose from increases the chances of making the wrong choice and tracking the incorrect data set.

This article will describe some of the available metrics for tracking memory usage in Microsoft's Windows NT/Windows 2000, Sun Microsystems' Solaris, and Linux.

Windows NT and Windows 2000

When monitoring ColdFusion memory usage in Windows NT or 2000, many developers use the "Mem Usage" statistic in the Task Manager. This statistic measures the working set size. Working set size roughly translates into how much of the ColdFusion process is being kept in RAM. Keep in mind, "Mem Usage" is NOT a measure of overall memory usage.

If overall memory usage needs to be checked periodically, use the "VM Size" column in the Task Manager. To view the "VM Size" column, make sure "Processes" is selected. Click on the "View" menu and choose "Select Columns". A dialog box will appear in which "VM Size" will be an option.

To monitor memory usage and log it over time, Performance Monitor will need to be used. In order to enable Performance Monitor to log memory usage statistics properly, "Pdlcnfig.exe" will need to be executed. Assuming that the system has Microsoft's Resource Kit installed, "Pdlcnfig.exe" will be located in the \WinNT\system32 directory.

This installs the performance logging service and launches the configuration window. To use the counter for ColdFusion memory logging, follow these steps:

  • Select "Process" in the "Performance Object" drop-down box.
  • Select "cfserver" from the "Instances" list.
  • Select "Private Bytes" from the "Performance Counters" list.
  • Click on "Add."

Set the log file name, and select the "Comma Separated Value" (CSV) file format if Excel charting is desired with the data. (CSVs can be opened directly in Excel.) Set the sampling interval (i.e., every 10 minutes) and start the performance logging service by clicking "start" or starting it via the control panel. If you get an error trying to start the service, reboot and try again.

If Windows is doing its job correctly, expect to see Mem Usage rise as ColdFusion runs. This just means more of ColdFusion is being stored in RAM and less is left out on disk while virtual memory is waiting to be paged in.

Remember, "Private Bytes" is the total virtual memory size of the cfserver process and equates to the "VM Size" metric inside Task Manage.

Neither of the statistics provided by the Task Manager or Performance Monitor will show memory being returned. That's because ColdFusion 4.5 incorporates the latest version of SmartHeap, which no longer returns unused memory to NT. Instead, memory is held, assuming ColdFusion may reuse it in the near future. While this method is faster and more efficient, SmartHeap can lead to confusion when looking at memory statistics on NT.

Read More. :- http://kb2.adobe.com/cps/175/tn_17517.html




Coldfusion Components also known as CFC's. A lot of people program Coldfusion and not use CFC's have; it's too hard to learn! It's too hard to learn?? No way!!

It's very easy to learn. It's just an other way of thinking than you're used to. You must see CFC's as building blocks. By constructing "building blocks" you're code is much cleaner and far more reusable, thus quicker to build your application. Most (if not every) ColdFusion Developer knows UDF's (User Defined Functions) and Custom Tags. CFC's are almost the same as Custom Tags, but have some differences:

  • Custom Tags have a single entry point; CFC's can have multiple entry points. This makes it possible to create a single component that does many related actions. (To do that with custom tags you would need multiple tags or cumbersome switch processing.)
  • Custom Tags have no formalized parameters passing and validation mechanism; CFC's do. In other words unlike custom tags, CFC's can validate passed data, enforce data types, check for required parameters, and optionally assign default values.
  • Custom Tags cannot persist; CFC's can. Custom Tags are blocks of code that are executed as is, while CFC's are objects and can be treated as such.
  • Custom Tags are designed to contain code; CFC's are designed to contain both code and data.
  • Custom Tags are accessible only by Coldfusion and only locally; CFC's can be accessed as web services, opening up a whole new world of reuse possibilities.

To sum it up, CFC’s and Custom Tags are quite different. Although their functionality does overlap a little, they really do not solve the same problems at all. So to learn the basics of CFC's while head right on it and start with some sample "spaghetti code" and transform it to a structured and reusable way; a CFC. Please note that this article only covers the basics of CFC's and does not handle any advanced topics.



More Information visit ColdFusion Development.


Looping is a programming technique that repeats a set of instructions or displays output repeatedly until one or more conditions are met.

The first thing that we need to do it to query a database

This tag supports the following types of loops:

  • cfloop: index loop
  • cfloop: conditional loop
  • cfloop: looping over a date or time range
  • cfloop: looping over a query
  • cfloop: looping over a list, a file, or an array
cfloop: index loop

An index loop repeats for a number of times that is determined by a numeric value. An index loop is also known as a FOR loop.

Syntax



Example
The loop index is #LoopCount#.

cfloop: conditional loop

A conditional loop iterates over a set of instructions as long as a condition is True. To use this type of loop correctly, the instructions must change the condition every time the loop iterates, until the condition is False. Conditional loops are known as WHILE loops, as in, "loop WHILE this condition is true."

Syntax



Example
The following example increments CountVar from 1 to 5.



cfloop: looping over a date or time range

Loops over the date or time range specified by the from and to attributes. By default, the step is 1 day, but you can change the step by creating a timespan. The cfloop tag loops over tags that cannot be used within a cfoutput tag.

Syntax




Example

The following example loops from today's date to today's date plus 30 days, stepping by 7 days at a time and displaying the date:



cfloop: looping over a query

A loop over a query executes for each record in a query record set. The results are similar to those of the cfoutput tag. During each iteration, the columns of the current row are available for output. The cfloop tag loops over tags that cannot be used within a cfoutput tag.

Syntax



Example



cfloop: looping over a list, a file, or an array

Looping over a list steps through elements contained in any of these entities:

A variable
A value that is returned from an expression
An array
A file
Looping over a file does not open the entire file in memory.

Syntax



Example

This loop displays four names:


You can put more than one character in the delimiters attribute, in any order. For example, this loop processes commas, colons, and slashes as list delimiters:



ColdFusion skips the second and subsequent consecutive delimiters between list elements. Thus, in the example, the two colons between "George" and "Ringo" are processed as one delimiter.

To loop over each line of a file, use the tag as follows:



To read a specified number of characters from a text file during each iteration of the loop, use the tag as follows:



To loop over an array, you can do the following:




More Information visit ColdFusion Development.


Challenges Facing by Coldfusion in 2009

Posted by semaphore007 | 9:55 PM

A year ago, I challenged the community to evangelize ColdFusion and convert new developers from other technologies. It was part of a blog post that examined and rebuffed several common arguments that often arise within the community as to why ColdFusion is not more popular. Most of those arguments focus on what people think Adobe should do to make ColdFusion more popular. A lot has happened in the last year since that blog post so I want to revisit the arguments and see where we stand today.

ColdFusion needs to be taught in schools. I argued that many programmers don’t use the languages they learn in school and, of course, almost all CFers are using a language they learned after leaving school! In 2008, Adobe announced that ColdFusion 8 would be made available for free to all students and faculty for teaching purposes and Adobe also committed to working on course curriculum materials to help push ColdFusion into schools. It’ll be interesting to see how successful this is but it will take several years before we can judge the results. +1 to Adobe.

ColdFusion needs to be free and/or open source. I argued that cost was a bit of a red herring because folks need to look at “total cost of ownership”. See the ColdFusion Evangelist Kit Adobe have produced for more information on that. So what about “free and/or open source”? Well, Open BlueDragon was released as open source in 2008, based on BlueDragon 7 so it’s a solid, well-established product. Railo released their 3.0 Community Edition which is free for production use and it’s also very full-featured (and very fast). Railo will be releasing their product as open source in early 2009, under the jboss.org umbrella, part of the Red Hat group. So now you have both free and open source options. Oh, and there’s also free hosting now for ColdFusion! +1 to OpenBD and Railo.

Adobe needs to provide more ColdFusion evangelists. I argued that other popular technologies (PHP, Ruby on Rails, Groovy/Grails, Python etc) have no paid evangelists, just the community. The economy makes it hard for any company to support extensive evangelism and makes it almost impossible to increase the amount of paid evangelism. At MAX, Adobe talked about their drive to support and increase the user group community however and launched an official hub for their rapidly growing number of user groups. They also provided the ColdFusion Evangelist Kit (mentioned above) to help every community member become a better evangelist. +1 to Adobe.

And what’s your challenge for 2009?

Same as 2008 - convert a non-CF developer to CF. Just one. C’mon, you have 349 days left. If all of you - all 500,000 of you - convert just one developer this year, we’ll double the community. You believe in ColdFusion - make someone else believe in it too!

This Article Written by :- Sean Corfield

About The Author
Sean is currently Chief Technology Officer for Railo Technologies US. He has worked in IT for over twenty five years, starting out writing database systems and compilers then moving into mobile telecoms and finally into web development in 1997. Along the way, he worked on the ISO and ANSI C++ Standards committees for eight years and is a staunch advocate of software standards and best practice. Sean has championed and contributed to a number of CFML frameworks and was lead developer on Fusebox for two years.


More Information visit ColdFusion Development.

Cold Fusion was created as a commercial product by the Allaire Corporation. As a commercial product it has some features different from other Server Side Scripting Languages. The first major difference is that Cold Fusion scripts do not have to display their source code like every other scripting language, it is possible to run encrypted versions of the scripts.

This allows for individuals to sell their own scripts without fear of piracy, however it has the side effect of stemming the flow of free open source CF scripts for use by the learning webmaster.

The second major difference is that Cold Fusion costs money. A server side scripting language works with an interpreter. Depending on the extension of the filename to be served, .php .asp or .cfm, the server will first send the file to an interpreter which is what dynamically generates your page. So to use these languages you need to install them on your server.

PHP is free, ASP is free, but CF costs money, and that may be the reason why it is growing only slowly. However most NT hosting packages do already include Cold Fusion so for the person who does not own their own server this pricing difference will not have much affect.

As to the language itself, I have worked with both ASP and PHP before and it is my opinion that Cold Fusion is the easiest to learn and use.

Read More : http://www.sitepoint.com/article/cold-fusion-tutorial/


More Information visit ColdFusion Application Development.

ColdFusion is a web application server and software development framework. Cold Fusion is a scripting language used by our developers to create dynamic websites. A dynamic website can change depending on outside factors like data, user preferences or changes in back end database. Cold Fusion is a rapid scripting environment server for creating Rich Internet Applications.

Cold Fusion is a programming language and Cold Fusion Markup Language (CFML) is an easy-to-learn tag-based scripting language on the same page as HTML.

Semaphore Software is one of pioneers in the area of Cold Fusion centric application development services in different application development frameworks like and ColdFusion Application Development , Application development outsourcing.

Our global presence, process oriented methodologies and efficient delivery models enable us to provide an integrated and highly flexible mix of on site, off site, near shore and offshore delivery options. We have built an impeccable reputation for providing professional software solutions that are delivered on time and within budgets.


More Information visit ColdFusion Development Services.

The countdown is on! CFUnited is just a mere 49 days away, and the excitement is building. I think everyone has great anticipation for Centaur this year--I know I do! I think the sessions are going to be absolutely great as well. I've never seen a lineup this good.

I'm also looking forward to speaking for the first time at a major ColdFusion conference. It's a little nerve-wracking, but I'm glad to not be alone. Aaron and I make a great team, and our presentation is going to be awesome! If you haven't checked it out, see all about it at CFUnited's site : http://cfunited.com/2009/topics/237

We're covering error handling with ColdFusion--a very hot topic and a highly popular request by the community. We're looking forward to sharing our experiences and knowledge gained through the years on this important subject. Hope to see you there!


More Information visit ColdFusion Development Services.

Semaphore Software is Expert in the field of Coldfusion Application Development. We have successfully integrated a variety of databases technologies with the applications and our Versed in Team of software professionals dedicated to provide reliable range of ColdFusion Services.

  • Client and server cache management
  • File indexing and searching service based on Verity K2
  • XML parsing, querying, and validation
  • Server clustering
  • GUI administration
Our team follows strict object oriented approach for application development in coldfusion. ColdFusion Application services are a set of built-in services that extend the capabilities of the ColdFusion scripting environment. Out team of ColdFusion programmers are also working for maintenance of existing ColdFusion applications developing the software in structured and planned process.



More Information visit ColdFusion Development Services.

ColdFusion is not Java. It is an abstraction layer of Java for programming web sites and hiding Java’s complexities… period, the end. It’s not an enterprise level language like Java and .Net are, yes it can work with both, but that doesn’t make it an enterprise level language. Because ColdFusion is a abstraction layer of Java, you can take the ColdFusion markup and smack on top of another language, say .Net (What do you think BlueDragon is, the ColdFusion markup on top of .Net). A better analogy for describing what ColdFusion is, would be to say that ColdFusion is like jQuery. jQuery is an abstraction layer of JavaScript, it make JavaScript easier by hiding it complexities.


However, it’s very feasible that your could take the jQuery markup and ideas and put them on top of another language, say Python. The design patterns that we’re all going crazy trying to utilize were written for enterprise level languages for a good reason. A lot of these enterprise level languages interface with many different systems and grab data from a variety of different places. As such Service Layers, IOC, Business Objects and numerous other design patterns were implemented because it does make it easier to manage and maintain.

However that doesn’t mean that the web sites we write warrant the use of all or any of these ideas into it, nor should we feel that we have to be implementing these ideas into our web sites. In closing, remember that ColdFusion was built to hide the complexities of the Java language and make it faster and easier for us to work with. Why are we trying to bring those complexities back in is anyone’s guess.


More Information visit ColdFusion Development Services.

Adobe ColdFusion 8The Journey of ColdFusion from Macromedia to Adobe adds scalability in the performance of web application development. As a part of the Adobe family, ColdFusion 8 offers unique solutions to internet applications in the web world. As its extensive features of simplicity to code and short span of time with high quality service makes ColdFusion Consultants the best option for web application development solutions. Now it comes with the best features among the existing web tools available in the market.

Apart from the other features, ColdFusion 8 provides some of the best known features in ColdFusion Programming:

  • ColdFusion 8 introduces the new server monitor and Multiserver monitor. Developers can able to utilize the memory and able to get the information from the server like requesting, queries, errors and other important services to reduce the defects while interacting with users.
  • ColdFusion 8 offers dynamically interaction with PDF forms or documents.
  • ColdFusion 8 allows accessing the large volume of library of Ajax user interface components with introducing new simple tags.
  • Able to access Microsoft .Net assemble classes as CFML objects.
  • ColdFusion 8 introduces new tags to interact with Microsoft exchange servers.
  • Now it expands its platform supports to Mac OS X on Intel, JBoss, JDK 1.5, JDK 1.6, Microsoft Virtual Server and 64-bit support on Solaris.
  • ColdFusion 8 improves interaction with Database.
  • It comes with strong encryption libraries.

These all advance features of ColdFusion 8 becomes a powerful tools in the ColdFusion Development life cycle. Now ColdFusion consultant is able to provide day to day challenging of internet application development. With all the broad features of ColdFusion, offshore providers are ready to provide offshore ColdFusion development works at feasible price along with attained quality works.



More Information visit ColdFusion Development Services.

This is probably obvious to most of you out there but, just in case you missed it there is a setting in the CF Admin panel that will help keep your cfclasses directory from getting huge.

On the "Caching" page of CF Admin there is a checkbox titled "Save class files" if you are in development you should seriously keep that UNCHECKED.

Here's an example to illustrate why that is a good idea. We are working on a semi-complicated CF app using Model-Glue and Coldspring. When the site is first hit, after starting CF server, 3,002 .class files are generated and placed in the cfclasses directory. Now, imagine you are editing and revisiting some of those files (or flushing the entire MG cache). That number keeps on growing and growing. Eventually, something will go wrong and you'll want to delete some .class files to make sure you are seeing the latest code. However, because your cfclasses directory is so huge you won't even be able to "cd" into it. Your system will appear to hang. Trying to delete the directories contents will take a long, long time.

What do you do? Well you just uncheck that damn box. That will prevent a huge backlog of files from building up in the cfclasses directory in the first place.


More Information visit ColdFusion Development Services.

This article will focus on practical ideas and habits that, when consistently applied, will allow you to develop and create better ColdFusion Applications – regardless of which CF version you use, the hardware you run on, or the methodology you employ – as well as make your development easier.

-> Know the Database

Many ColdFusion developers do not take advantage of the power and features of their database, often trying to solve problems in ColdFusion that are better solved through the use of SQL and or specific features in their database.

The main reason for this is that many CF developers feel the need for more than an understanding of SQL syntax and basic relational database theory. As a CF developer you need to understand that each RDBMS has specific strengths and weaknesses, and powerful tools and features that can make your life easier and your application more scalable and robust. The database may also have features that, if not understood, can make development more difficult.

Make sure you have read up on your particular DB and are at least aware of what it can do for your application. For example, many developers try to port code developed for MS SQL to Oracle, and find their join statements throw exceptions, never realizing that while their SQL is correct in the generic sense, Oracle does not support the Join statement and requires you to use the symbolic representation for a join rather than the literal statement.

When building applications, try to build your data model and data access routines independently of your application code. In Web application projects, it can be impractical to totally abstract the data layer from your code, but even in smaller projects you can write many of your queries independently of your ColdFusion code and use literals in the place of variables. In larger applications, and depending on your architecture, creating CFCs, CF custom tags, or templates that you later include into other code that contains your data access and manipulation code, makes a lot of sense. It allows you to test your SQL, reducing the amount of redundant code written, and increasing code reuse. Finally, it also allows you to use database tools to help analyze your SQL to increase performance and find bottlenecks.

-> Style, Code Standards, and Readability

Developers tend to think about how to solve a particular problem in the most efficient or interesting way. They tend to forget that the most important thing in building an application that will be used and supported is maintainability.
The first thing you should always do when building any app is select or create style and coding guidelines. If you do not have one, Macromedia’s internal Web development group has published their ColdFusion Coding Guidelines at http://livedocs.macromedia.com/wtg/public/coding_standards/contents.html. Regardless of what you choose, you need to make sure everyone in your development team adheres to it. Also remember that nothing ever stays in stasis and at times it makes sense to change your guidelines. When you do, be extra rigorous to make sure that people switch to the new guidelines.

Creating clean and understandable code is an art in itself and in most Web applications is far more important than creating the most efficient code. The reason for this is that with almost all Web applications, performance problems can be dealt with at a hardware and networking level, as long as your code and database are reasonably well designed (also, in my experience most performance issues reside at the database level). It is almost always easier to solve performance issues with more hardware than it is to try to rewrite your code to be more efficient. Also, hardware is a fixed capital cost, but labor isn’t. In almost every project, labor associated with development is the single largest expense.

Furthermore, as applications grow and change over time, the underlying code often needs to be changed. Having code that does not conform to a documented standard makes it harder to collaborate and support any system regardless if it’s ColdFusion or COBOL. While rigorous documentation can add to your development time, sometimes it actually speeds up development dramatically in that you actually know what you need to do when you sit down in front of your computer. Regardless, it's more than worth the effort to document your system to make it easier to support in the future.

-> Think Before You Code

Before you ever write a line of code you should have a clear understanding of what you’re about to do. There are many approaches to creating requirements, modeling systems, developing methodologies, etc. However, CF allows for such ease of development that many people start coding without clearly thinking about what the application needs to do. What’s worse they tend to come back at a later date and slap on more code to create new features, without planning or thinking through what effects those changes will have on the system as a whole.

Before you start to work on your application you should create wireframe diagrams, logical flowcharts, and plainly written descriptions of what the application needs to do. You also need to document what your user is expected or required to do at each point in the processes that require user interaction. There is a large variety of methodologies for describing software systems, and some are very intense and demanding, such as the Universal Modeling Language and Unified Process. Others are much more flexible and easy to use, such as those described as Extreme Programming. Regardless of what you use, you should adopt some method of designing and describing your application and follow it all the time.

Most important, don't reinvent the wheel. If you're working on a problem and think it's something that people must have run into before, you're probably right. Make sure to use the tag libraries, your local user group e-mail list, and resources like CFCzone.org, CFlib.org, CFComet.com, Macromedia Dev Center, etc. Good programmers will always use or reuse good code when possible so they can focus on developing the application as a whole.

-> Exception Handling

People have different definitions of what exception handling is, and often make it synonymous with error trapping. In this article I will differentiate between simple trapping errors with CFTRY/CATCH blocks versus actually dealing with unexpected or unforeseen events, and creating a process to deal with those events. You can break down exception handling into several distinct categories: trapping, notification, and logging.
Trapping

This is what most people confuse with exception handling, which is the catching or trapping of errors, usually through a CFTRY/CFCATCH block and/or a CFTHROW command. You should use CFTRY/CFCATCH blocks in your code where an error or exception may occur, such as a CFQUERY, in that numerous unexpected things can happen in a query from a query failure to the database being down. Once you have trapped your error, you need to do something with it. The first thing you need to do is logically decide if the error needs to be dealt with in some way such as attempting to retry the failing process or notifying a system administrator.

Notification
Notifying a user of an error or a problem is often a good idea, but sometimes it can be a bad one. Many developers use e-mail to notify administrators of every exception that happens in an application – a classic mistake of beginning developers. In your planning stage you should think through what exceptions you need to notify a user about, or if you need to notify a user based on a threshold.

For example, you may have implemented a site-wide error-trapping system that e-mails a user whenever there is an exception. One day some new code is integrated that causes an exception every time a user comes to the site. Imagine if you have 70,000 users in an hour. You can easily see how this might bring your mail server to its knees, cause huge performance slowdowns in your server, and generally annoy everyone who is on the receiving end of the notification e-mail.

This is why you need to think through your notification and exception-handling strategy, and in this particular case, you may want to implement a threshold strategy where notification is sent based on severity and frequency. In addition, many errors should first be handled by the system and, if possible, the user should never know a problem has occurred. At the very minimum you can define site-wide error handling in the ColdFusion administrator and refer the user back to the home page. Users should never see a "raw" error message not only because it makes them uncomfortable, but also because it can expose information about the system that then creates a security risk. Many "crackers" purposely try to create exceptions in Web applications so that they can try to gather information that they can exploit to get access to the system.

Logging
Many CF developers confuse logging with notification and assume that since CF logs errors, and they have been notified by an error, that is all they need to do. In general, you want to think about what kind of exceptions the system might generate and what you are concerned about, and then log them when they are created. This can help you go back and reduce bottlenecks in your application and find hard-to-reproduce bugs, as well as look for hack attempts at your system. CFMX now makes use of CFLOG, which allows you to easily log your own information about any event you like and is a great way to log additional information about an exception when you trap it.

-> Testing Your Code

Most ColdFusion Developers never really test their code, but would rather build their applications and work on a trial-and-error basis until the users are happy. This often leads to never-ending development cycles as well as bugs that appear after the project has been completed. Testing is a lot more than just making sure that the code runs, or changing features until the client is happy. Good testing can actually allow you to increase the speed with which you develop applications, reduce your frustration level, and increase the long-term maintainability of an application.

Testing forces you to think about the application and what you want your code to do beforehand, by forcing you to write your tests before or in parallel to your application code. If you cannot create a test for your code it often means you don’t have enough information about what you need to develop, and should revisit your design and documentation.

Recently, the concept of unit testing and "test to code" practices have become more popular with ColdFusion, and now there are several useful tools. One of these is CFUnit, which is based on JUnit. It’s available on the Macromedia DevNet Resource Kit (DRK) Volume 3,www.macromedia.com/devnet/mx/coldfusion/articles/cfunit.html. Also, Steve Nelson of Fusebox fame has developed a testing harness for Fusebox developers at www.secretagents.com/index.cfm?&fuseaction=tools.listtools. Finally, there’s an open source ColdFusion testing initiative called ColdUnit, which shows great promise: http://sourceforge.net/projects/coldunit/.

-> Keep Learning

No matter what your level, you need to keep learning and pushing the envelope of your knowledge. Paradigms and practices in software development are always changing just like in any other discipline, and it’s up to you to keep pace. Good programmers are always monitoring best practices, discussing problems with their peers, and learning new programming languages and technologies. One of the great things about ColdFusion is how easy it is to integrate Java, .NET, and XML. Other technologies and many problems that are extremely difficult to deal with using ColdFusion only are trivial when you use another language, but you won’t know that if all you do is focus on ColdFusion. Another great way to learn is to contribute to online discussions, and better yet, to contribute to your local ColdFusion or Macromedia user groups. If you want to learn a topic or really see if you know it, try teaching it to others.

-> Always Use Source Control

Most ColdFusion Developers never use source control – even on large projects! While most ColdFusion developers may not think they need to use source control because their project is small, using source control can save you development time, allow you to track your work efforts, provide valuable backups, and allow you to easily manage many similar projects. This also applies to projects that you’re doing yourself or at home. You’ll save yourself a huge amount of frustration knowing that you can always revert to an earlier version of your code; also, the best time to build these habits is when you’re working on your own. There’s no good reason not to use source control and once you get into the habit, you’ll find it takes no more time to use it than to not use it.

There are many excellent source control products out there, like Borland’s StarTeam product, which is also a great tool for collaborative project development. Make sure to look also at Concurrent Version Control, which is the standard for concurrent version control and is available as a free open source tool from www.cvshome.org/. Windows versions are also available. If you’re not using source control or version control, start now!

Conclusion
Probably the most important point of this whole article, and what differentiates good programmers from average ones, is that good programmers make all the above strategies habits! Many of us apply some or all of the techniques described above in a haphazard manner, and use them when it’s convenient or when there is no pressure. Really good ColdFusion Programmers do them as a matter of habit no matter what the pressures or time constraints are. The best way to improve as a developer is to always apply the same standards in development no matter the size of the project, even if you’re just coding for fun.



More Information visit ColdFusion Development Services.


Semaphore SoftwareSemaphore Software has been developing ColdFusion applications — e-commerce websites and online content management solutions. There has not been even a single instance of project failure during this triumphant phase of ColdFusion web development. But why web development with ColdFusion and not with some other programming or scripting language such as PHP, Ruby on rails or Python? ColdFusion is so fast, Sometimes it seems like magic. It is a language specifically evolved for enterprise level solutions, although it can be easily used — without resorting to an overkill — for smaller websites and applications too. In fact you can use ColdFusion for static web sites too but it is rarely done. It can be easily integrated with any platform from Java to .Net and it supports all Web 2.0 web development features and enhancements such as Ajax and user generated content management. Most of the online content and document management applications are developed using ColdFusion because of its unmatched features.

The web development methodologies at Semaphore Software are time-tested as well as innovative; sometimes we strictly follow the rules and sometimes we define our own rules in order to deliver the maximum benefit to our clients. As a first step towards delivering world-class online application solutions we have only been focusing on programming in ColdFusion. Other than that our strict quality control mechanism is a self-regulatory system that is set in motion as soon as a new project initiates.

We employ highly modular web development techniques while developing solutions for our customers. Due to a very high efficiency level we are able to minimize the time spent on web development and maximize the output and hence charge a very reasonable rate from our clients. Of course ColdFusion has a great part in it because when you work in ColdFusion coding efficiency is handled by its environment automatically.

Our web development activities are mostly centered around developing highly advanced e-commerce and online content publishing solutions for our clients from all over the world. You can easily say that when it comes to developing e-commerce and online publishing applications we have developed an incomparable expertise. We have left no stone unturned trying to understand all the aspects of this great niche.


More Information visit ColdFusion Development Services.

Today, outsourcing has almost become the order of the day. So why are global organizations choosing outsourcing to India ? More and more global companies are choosing to outsource today for a number of reasons, such as, cost-effective services, increased efficiency, increased productivity, shared risks, reduced operating costs, increased quality, better services and more time to focus on core competencies.

ColdFusion is the hottest way to create dynamic webpages that link to just about any database. ColdFusion is a programming language based on standard HTML that is used to write dynamic webpages.

ColdFusion is an application development language of choice. ColdFusion is a web application server and software development framework. ColdFusion lets you create pages on the fly. Creating an application with ColdFusion is as straightforward as creating a static Web site.

The main unique feature of ColdFusion is that web pages have the server–side ColdFusion Markup Language (CFML) in addition to HTML. CFML gives you the ability to control the behavior of your applications, integrate a wide range of server technologies, and dynamically generate the content that is returned to the Web browser.

If you have Coldfusion project to be developed and have limited budget and cannot compromise on quality, then you can Outsource ColdFusion development to India.

Outsourcing to India can give your organization a competitive edge. The following are a list of reasons why companies outsource to India.

1. Cost-effective services
2. High-quality services
3. Time Zone Advantages
4. India’s stable government
5. Global organizations’ most preferred choice

At present, India is emerging as one of the popular offshore outsourcing locations to offer cost effective software solutions. The contribution of India in Software Outsourcing India is remarkable. As stated above, the prime reason for choosing India, as an offshore development partner in offshore IT Outsourcing business is the availability of enormous pool of educated manpower combined with world-class quality offerings. Beside this, India has many speakers of English language, which further aids them to work with or for any part of the world.


More Information visit ColdFusion Development Services.

I had been meaning to publish this for a while but I decided to sit on it and wait for some of the dust to settle. I was eager to see exactly how many people would join the new Broadchoice Railo.

Now that Railo has finally opened up I think it is high time we take stock in the CFML landscape. What follows is how I view it with (of course) my personal twist/insight in each engine. I've tried to keep my personal commentary to a minimum, or at least hold it off till the end.

Open BlueDragon is GPLv3. It is the most open system with the most open development, though I think we could improve some. Anything that comes from OpenBD is GPLv3 or compatible. It is extensible but currently does not offer any store or other automated mechanism to add the extensions to the engine (though it is not hard and it is documented). So long as a commercial extension does not try to package and distribute the entire engine there are not problems with commercial extensions. Open BlueDragon is backed by a AW2, not New Atlanta. AW2's business model does not rely (primarily) on the CFML engine, though they do leverage it in some of their work from what I understand. When OpenBD was announced the project tried to gain confidence from the community by include some high profile names in the project steering committee (personal observation: BlueDragon had a bad name due to some old NA bad blood with Adobe and many were skeptical).

Railo is LGPL (sorry I can not remember the version I think 2 but maybe 3). It is mostly open. The core offers compelling compatibility and an astounding set of functionality. It is extensible via an app store type model where modules can be added onto the engine (I have not done enough looking to see if this is still manual or automated through the admin). Railo itself plans to make some functionality for pay. Railo the engine is backed by Railo the company and the business model s structure entirely around the Railo engine (services and product sales). Railo has positioned themselves inside the CF community as a competitor to Adobe by sponsoring CF centric events and hiring prominent figures in the CFML community.

ColdFusion is currently the most closed (in terms of source and openness to talk about what is being worked on). It is commercial and when you pay you get the whole kit and caboodle. ColdFusion can be extended through a couple of different means but not quite as tightly integrated as Railo or OpenBD at this point (the main extension point at the Java level is through CFX tags). ColdFusion is the original engine to use CFML and has gone through 2 acuisitions. It's a steady income for Adobe, they care about the CF community and do their part to keep it alive and happy (it is after all steady income for them).

To Adam Lehman's credit I think the information about CF9 has been much more open than previous releases. Don't take this comment too lightly this is a large shift for a large corporation. This comes from some one involved in many previous releases of ColdFusion and I personally see a huge difference in this release. The last couple of releases of ColdFusion have been driven heavily by the community. This is good but at the same time, the community is not full of big thinkers and typically we ask for functionality we need right now. This has resulted in stagnation of the ColdFusion platform, sure it has kept up but it has not PUSH forward much. Let's face it while Adobe (and Macromedia before them) have done a stellar job developing a great product the whole platform itself has sort of dwindled as they have focused on the language too much (not saying the platform has not grown it has but more evolutionary than revolutionary). The innovation seems to have slipped away and as a direct result we have multiple engines available to us now.

Ok now that I got my little side bar tangent out, which engine is right for you? I'm not going to make that decision for you, what is important (in Open BlueDragon team's eyes) is you have an option. We see that as possibly the most important part of being available, you have options. Each engine has compelling reasons to consider it for use. For me personally, in my development, I like the fact that I have complete control over the source code if I need/want it. I like that and that drives me towards OpenBD. For my company, we like a solid platform backed by a single entity and ColdFusion offers that to us.


More Information
visit ColdFusion Development Services.

ColdFusion as one of the server side scripting language has many advantages over its competeting languages and helps to build power web applications and services. ColdFusion is being utilized in small & large business and also for some advanced personal use but it is hosting especially for business website.

The language used in ColdFusion Programming is ColdFusion Markup Language (CFML). It comprises of tags similar to HTML for querying databases, interaction with different services and outputting text. The basic components of ColdFusion programming are ColdFusion Server and Studio. Here ColdFusion server is the application that processes the CFML code and the ColdFusion Studio is being used in ColdFusion Development if programmers develop their application locally and move to the ColdFusion Studio, when it is fully ready to process.

The major benitis of using ColdFusion Consultant is its easiest ways in developing websites among other available web tools in the market like ASP, PHP or JSP. Within a short period of time, web developers can code ColdFusion Programming rapidly because of its simplicity as well as its supportive qualities with other platforms like Apache, IIS, NSAPI based web servers, Solaris, HP-UX and Windows.

It also works with Dream weaver, Flash, Fireworks and Freehand of Macromedia as ColdFusion once was acquired by Macromedia. The new version ColdFusion 8 is come with extra features such as it can now dynamically generate and interact with PDF documents, features of a Multiserver Monitor to gain insight on all servers in a cluster, using simple tags to access a large library of pre built Ajax user interface components, able to specify any .NET object either local or remote and use it in any ColdFusion applications and more features which boost to its popularity in ColdFusion programming and among all other web clients world wide.


More Information visit ColdFusion Development Services.

Most people are familiar with Microsoft Project - project management software that allows you to manage many aspects of projects including tasks, due dates, progress, and people assigned to specific tasks.

Microsoft Project Server is an enterprise storage product that facilitates sharing project plans created with Microsoft Project with other people in a company, especially other project managers. Project Server enables you to manage a workforce by tracking all projects in common and giving you a view of all projects that an individual may be assigned to. Chances are that any large organization will have more than one project manager and using a centralized storage point allows for better group management of projects. In this kind of environment, Project Server acts as the central repository and Microsoft Project acts as a client to access that information. Project Server also provides a Web interface for viewing the status of projects.

The principal (recommended) way to integrate with Microsoft Project is by using the integrated Project Data Service (PDS) that's included with Microsoft Project Server. PDS is a SOAP Web service that translates incoming requests and manages their entry into the system. The most common integration pieces are external user management, timesheet systems, and ticketing systems. The PDS exposes pieces of the puzzle that allow you to integrate with these external systems and to integrate all the parts of your organizational project systems.

The PDS will allow you to create projects, tasks, resources, as well as log time against projects and run administrative reports on information in the system. Granted, for most integration you'll want to use the Microsoft hooks into other Microsoft products. For example, Project Server boasts excellent integration with Microsoft's Outlook Exchange, Active Directory, and Sharepoint. If those are your only integration points, any work you would need to do is done by Microsoft, but if you need to work with a non-Microsoft product, read on.

Often times the largest integration obstacle is simply learning how a product works, and that can easily be the case with Microsoft Project. The initial learning curve of Microsoft Project may be steep but it's worth the hurdle to reach familiarization with the application before and during your implementation.

Read More ...


More Information visit ColdFusion Development Services.

Coldfusion 8Recently I was asked to install a java CFX tag in the ColdFusion 8 Multi-server Configuration. I figured this would be an easy task, as I had done this many times before in the standalone server configuration. I went into the ColdFusion Administrator and installed the CFX tag as normal. However, when I called the CFX tag from the code I received an error that I had never seen before. The error was 500 com/allaire/cfx/CustomTag.

After trying everything I could think of, I decided to compare the java class paths between the stand alone configuration and the multi-server configuration. I found that the cfx.jar file was missing from the java class path in the multi-server configuration. ColdFusion therefore could not load com.allaire.cfx.CustomTag class. So, I decided to add the cfx.jar file to the java classpath and see if that would solve my error. To add the cfx.jar file to the classpath in the ColdFusion multi-server edition you must follow these steps.

  1. Open the jvm.config file located at
    {application.home}/bin
  2. Add
    {application.home}/servers/cfusion/cfusion-ear/cfusion-war/WEB-INF/libto the section java.class.path"
  3. Save the jvm.config file
  4. Restart the ColdFusion service.
After restarting the ColdFusion service, login to the CF administrator and go to the settings summary. Confirm that the cfx.jar file is in the java classpath. It was there, and I was able to call the CustomTag from my code.

More Information visit ColdFusion Development Services.


I am starting from scratch, putting in a unit testing framework, and working within the existing organization's culture to introduce enough of the tool’s benefits without burdening the organization with too many of the downsides. Everything has a downside, a cost, or whatever you wish to call it. There is no free lunch.

The first steps were to gage the organization's desire for the possible benefits of a unit testing framework, and their willingness to commit to moving forward, and accepting the cost. Having been in an "extreme" programming environment, which was only "extreme" in the sense that projects were "extremely" haphazard and "extremely" mismanaged, making sure that people are clear on what can be expected from implementing some test automation for unit testing and regression testing. Automated does not mean that you do nothing, and the machine does everything. It is difficult to know what people have been sold by the trade journals, and blogs, and common terms are often misappropriated.

The current environment is Flex/Actionscript and HTML, with a ColdFusion backend, with a ColdSpring framework.

The goals are:

1) Automated testing with Ant, with performance metrics logged in a database, and pass/fail results e-mailed nightly to interested parties. (Thorough regression testing and reporting is key).

2) Eclipse Integration or reasonably nice Unit Runner, with easy ability to select individual tests, or test suites. (Easy sell to the engineers is key)

3) Mock Objects, automated test generation, anything to minimize the time impact on engineering, while maximizing the benefit, and keeping the program moving.

Sean Corfield had mentioned MXUnit fairly recently, so it seemed worth a look. Given the higher volume of activity on MXUnit, when compared to CFCUnit and CFUnit, it seemed like a reasonable way to go, for the best of all worlds for future itegrated add-ons. The first downside I will mention is that *MXUnit’s Eclipse Integration is Not Flex Builder 2.01 Compatible, or rather, not compatible with the version of Eclipse (3.11) that ships with Flex Builder 2.01* This wasn’t super clear from the MXUnit website, so it’s possible for an engineer to go through the installation instructions, and end up with a failing plug in. This might not be a problem for some organizations, but may be for others. Most of the team has not yet upgraded to FB 3, so it could be an issue at the moment.

MXUnit's Eclipse integration isn't quite finished, or at least that's how it felt for me. It "worked", but was lacking a few things that I thought were important. An html or Flex based unit runner will do the trick though, so it's not a huge problem.

The things which make the integrated unit runner a little less than usable, for me, are:

1) It seems to have no memory of past tests, so I would have to go through the selection process for the unit test every time; some way to save the available test cases/test suites would be desireable/required,

2) The test case selection process was awkward; I found myself unable to select a Test Case which I knew was present on more than one occasion; This could be forgiven more easily, if it would remember the test cases I had selected in the past, but I was required to select/find the test case with each restart of Eclipse, or any time I wanted to switch tests

On the plus side, the ant unit runner does a great job, and it is clear how to modify the ant task. The availability of the different test result formats, allows me to feed the results into a variety of destinations with ease. The key item was logging test results and performance metrics, and not just logging into a text file, but logging into a database table, so it could be consulted for history. I was able to hack this item in really easily using the cfquery output format for the testResults.

I should at least mention that CFUnit and CFCUnit are both seemingly capable frameworks. I was able to set up integrated Eclipse (with Flex Builder 2.01!) unit tests, and test suites. But the availability of the test Result Formats, and the volume of project activity, were enough to convince me. That does not mean that I am right, nor does it mean it is the best choice for everyone. But the software selection is but one small piece of the puzzlement.


More Information visit ColdFusion Development Services.


This ColdFusion Optimization guide is a work in progress document based on research and experience.

Boolean variables will only work reliably in conditional statements if their value equals "true", "false", 1, or 0. Type coercision from 1 or 0 is not consistent, so check against "not false" or "GT 0" explicitly.

Use cfswitch instead of cfelseif branches

Use cflocation with a reference to a serialized data file or URL parameters to pass data from an action file to a display file instead of cfinclude. This will redirect the browser and append the action page to the browser history. This prevents multiple attempts to update to the database if the user refreshes the display page, which would occur if a cfinclude was used.

Immediately read, parse, and delete uploaded files after inserting validated data into the database to prevent DOS attacks

Use to suppress whitespace, since nothing gets into the output except what’s between a cfoutput tag, plus it is automatically applied throughout the codebase, and can be turned off without deleting or commenting an end tag

Do not add a trailing slash in the definition of the configuration parameter in application.cfm such as the document root or a base URL, since it is easier and more readable to use a slash after referencing the variable, and will prevent double slashes from causing path not found errors.

Use Len(CGI.xyz) GT 0 instead of IsDefined("CGI.xyz") to check whether the length of a CGI parameter is greater than 0 instead of checking for its existence, since different Web servers support different CGI environment variables, and CGI.xxx is always defined, regardless of its value

Limit concurrent updates to the database using CFTRANSACTION, not CFLOCK. CFTRANSACTION
will affect all accesses to the data being updated, not just those occurring in your ColdFusion code.

Use IsNumeric to distinguish between the number zero and an empty string for type checking conditional statements

Use a blank onrequestend.cfm to pair with application.cfm and speed up processing

Put cfoutput tags outside of loops to avoid unnecessary processing overhead

Use the maxrows attribute in cfquery tags when retrieving a known number of rows

Use init methods for components to pass in default values for public parameters that will be used in multiple methods

Use cfscript to initialize a group of variables instead of multiple cfset statements

Use the length function instead of isdefined to check for existence

Check for existence to avoid initializing variables more than once

Always use cfargument in component definitions and specify whether the required attribute is true or false unless a default value is expected

Use structKeyExists(arguments, "arg_name") to test for the defined arguments with no default or required value

Always define an init method for components and set var scope for cfc variables

Include the encoding description at the top of each page

Use compareNoCase(string1, string2) NEQ 0 instead of string1 IS NOT/NEQ string2

Use listFind instead of the OR operator

Use len or isdefined with a scope specified to check for the existence of variables

Put series of string or numeric data in an array instead of a list for operations other than loops

Always use cfqueryparam and blockFactor(calculated by: 3200/ total byte size of one row) in cfquery tags

Never use the evaluate, incrementValue, or iif functions

Use struct[key] instead of structFind(struct, key)

Use the val() function to ensure the validity of a number before inserting it into a database

Use the trim() funtion to remove whitespace from a string before inserting it into a database

Use a cfc, cfimport, cfinclude, or custom tag instead of the cfmodule tag

Use cfsavecontent instead of the cfcache tag to cache dynamic content

Use XML, SOAP, REST or XSL instead of wddx

Use cookies and URL parameters instead of passing local variables to check the state

Never use pound symbols on variables inside of a cfset, cfif, or cfscript tag

Use query of queries to loop or join cached queries. This enables pagination without multiple database queries. Check session or cookie authorization when accessing cached data

Use cflock when setting application or session variables

Use session-scoped locks for session variables and named locks for application and server variables.

Initialize global component objects once as application variables using the Singleton pattern instead of creating new instances for each part of the application

Use custom tags for reusable UI widgets, closures, and recursive code that generates dynamic content

Use cfincludes for page specific code that needs to reference application and local scope parameters implicitly

Use components for secure domain specific data, web services, encapsulating business logic, and sharing common functions through a single library

Use user defined functions for complex algorithms and procedures that can be used in multiple instances. Read More...



More Information visit ColdFusion Development Services.


The license of Coldfusion is, and should be, a very small part of any business budget, especially if you happen to be in a country where bandwidth is more expensive than average, like Australia. Also, Coldfusion 8 has Developer(from memory, limited to 1 IP) and Trial editions(from memory, 30-day trial unlimited IP), which are free. So you can start learning or developing immediately.

A big advantage of coldfusion has is its development time, it was first developed as Rapid Application Development Platform/Framework, and still is very quick to develop and deploy in.The time spent on development is considerably less, even if it saves 1 developer 1 min a day, and who worked about 230 days a year, divide the number of your developers by the licensing fee per year. Same reason why software developers and/or software development companies don’t mind paying for good development tools.

Another is its tie in to Flex, and it will be the defect o choice due to integration with Flash. Thought that may change in the future, since Flex is going opensource and PHP will probably have extensions written for Flex integration. I can’t imagine the .Net platform supporting Flex too much, as it may undermine MS own Silverlight product.

One additional point is that Coldfusion is largely backwards compatible, the last rewrite was CF 6 when CF went to a JRun/JVM backend, after which very few functions/tags have been dropped. Which is something Adobe had the sense to maintain so far in both CF and Flash environment.

Over the next few days, you will see a fair number of people grumbling about the pricing of CF 8, which has not increased dramatically (besides R&D isn’t free, and the software engineers need their paycheck!). But no other web application platform today can offer what Coldfusion out of the box, from image manipulation, PDF integration, Flex integration, Exchange Server integration, dynamic presentaions on the fly, etc.

Coldfusion has lots of features but there is a business case for each,

e.g. PHP will do the job for most companies public facing websites why pay more than you need to ? PHP also has numerous framework and CMS, many of which are opensource. ASP.Net has loads of exposure in Higher Education Institutions, so it should be easier to find suitable staff, and tie-ins to Microsoft’s CRM and Sharepoint products.

A brief summary (As my experiences so far) between Coldfusion, PHP and ASP.


ColdFusion
PHP
ASP.Net

Coldfusion
PHP
ASP.Net
CostsHigh, comes with a lot standardFree to High, Free version is well Free, but there are numerous commercial packages/add-ons like file compression, dynamic caching, advanced server monitoring/managementIncluded if you have a Windows Server License.
ComparationFaster comparativelyFairly Fast but falls somewhere between CF and .Net most of the time, catches up with commercial packages/addonsLonger than the other two
SpeedFast, with proper setup of JVM, even faster. Scales well with size and loadFast though may have problem scaling without addonsDecent, sometimes rather slow.
Integration with other languagesJAVA, Flex/Flashnon-native(non that i know of).Net, Silverlight, C#
Developer CommunityNot as big as PHP or ASP.Net, but still a decent presence is expected in most major cities.Big, anyone can pickup PHP, tend to have a large spectrum of skill levelBig pool from Higher Education Institutes. Well supported and backed by MS


More Information visit ColdFusion Development Services.