1. <cfinclude template="file.cfm">
   This is the most basic server-side include, which pulls one file into another. There is no way to send parameters to the included file (besides setting variables before the include). The included template can by dynamic using a #variable#. Unlike classic ASP, the file is included only when the tag executes.


2. include "file.cfm"
   This is the cfscript version of the cfinclude tag and behaves similarly.


3. <cf_file attribute1="value1">
   This is Custom Tag syntax. You can use this to send parameters at an included file. In this example, file.cfm exists either in the relative current directory, in a custom tag path specified by your Application.cfc file, or in a custom tag path specified in the CF Administrator.


4. <cfmodule [name= or template=] >
   Similar to the custom tag model, but you can use any file with a relative path.


5. <cfimport namespace="imported"> ... <imported:file />
   Specify a directory and namespace, and you can use this JSP style include. The cfimport tag must be applied on every template you wish to use the namespaced file set in. Imported files behave like custom tags in that they use attributes and can have a closing tag, but it can also be used for JSP tagsets.


6. <cffunction name="reusable"></cffunction>
   Defines a reusable function, method or subroutine of your application. You can type this anywhere in your application, except within another function.


7. function reusable() {}
   This is the cfscript version of cffunction. Since CF9, it can use extra syntax to give more metadata and control like the tag-based version has.


8. <cfcomponent> ... </cfcomponent>
   This is the root element of a .cfc file. Any code within is executed immediately upon instantiation (see cfobject). The methods (functions) within are executed upon request.


9. component { ... }
   This is the cfscript version of defining a CFC. This also provides the only way to write cfscript without the cfscript tags.


10. <cfobject >
    Creates an instance of (a.k.a. "instantiates") an object, which could be Java, .NET, a web service, or a variety of others, but in this case, we are talking about creating an instance of a ColdFusion Component (CFC) or ColdFusion web service.


11. createObject("component", "myComponent")
new myComponent()
    cfscript versions of cfobject and traditionally the easiest way to create an instance of any CFC.


12. <cfinvoke>
    Invokes a method on an object or webservice, instantiated or not.

• It's hard for your users to remember or even type
• It's ugly to see
• Your web stats say everyone visited one page - index.cfm - they had different query strings, but they only visited one page
• Your SEO is hurt. How does the googlebot know the difference in importance between the fuseaction query param over any other params? Sure, it's smart, it knows, but it can't really know, you know?
• It reduces the number of results in this search

• CFM pages everywhere.
  This is generally the opposite of using a framework. All of the hassle, none of the benefit.
• URL Rewriting. As requests come to the server with an attractive URI, they are translated into whatever your application needs to load it by.
  This is a good strategy, and it works well. On Windows with IIS, most of the software is either expensive or buggy, and definitely not portable. On Apache, mod_rewrite is great. Either way, you cannot make a cross-platform solution, meaning URL rewriting on an open source project is a no-go.
• Generated CFM pages everywhere.
  You have software that spits out static files from dynamic actions in your framework, that call back in to your framework. In our example, a /main/default.cfm page would be generated that may set the fuseaction querystring parameter and invokes the framework. This is a great solution, but I've never heard of anyone putting it to practice. Writing this software is deceptively complex.
• The OnMissingTemplate rerouting method.
  You link to pages that do not exist, then have an onMissingTemplate handler in your Application.cfc file that redirects requests to your framework with the right parameters. This new URL might look like example.com/main/default.cfm, which doesn't exist, so your onMissingTemplate method fakes like it's the ugly URL and invokes the framework.

<cfinclude template="../model/main.cfm" />
<cfinclude template="../view/main.cfm" />

<cfparam name="action" default="main" />
<cftry>
  <cfinclude template="controller/#action#.cfm"/>
  <cfcatch />
</cftry>
<cftry>
  <cfinclude template="model/#action#.cfm"/>
  <cfcatch />
</cftry>
<cftry>
  <cfinclude template="view/#action#.cfm"/>
  <cfcatch />
</cftry>

<cflocation url="controller/main.cfm" />

<cfinclude template="../model/main.cfm" />
<cfinclude template="../view/main.cfm" />

<cfset name = "Nathan" />

<cfoutput>Hello, #name#!</cfoutput>

1. Gives you something to blog about
   
   I have like 2 posts for the entire year so far. I need some new subjects.
2. Ups your search results ranking, bringing more traffic to your web site
   
   And who doesn't want more traffic? Not me, man, I want it all.
3. Increases the stability of the global knowledge on the given subject
   
   Maybe esoteric and meta, but it's true. Sometimes old resources go dry, while new ones are usually prettier.
4. Increases the keyword rank
   
   Increase the google trends ranking. Increase the general popularity of your subject. Get uninitiated people interested in a "that looks easy" kind of way.
5. Gets uninitiated people interested
   
   If you have them saying "Hey, I can do that, it's easy" then you can add to the numbers of those working in your world.
6. Guarantees your high place in the minds of the unknowing
   
   Readers like a hero, and you'll like people coming up to you, years later, expressing their gratitude.

public String Name;

private String _Name;
public String Name {
   get {
      // some code
      return _Name;
   }
   set {
      // some code
      _Name = value;
   }
}

reactorObject
 reactor.DataObject
   reactor.DAO
     reactor.myTableDAO
       myTableDAO
         myTableDAO_MSSQL

WHAT IS WRONG WITH THE W3C?

<cfcomponent extends="superbean">

(in component user, extends BasicGenericBean)
function getName(){return "Bob"}

(Outside, calling methods on the object)
user.setName("Nathan");
user.getName(); // returns Bob

<cfcomponent extends="GenericBean">
   <cfproperty name="Name" type="string" />
</cfcomponent>

user.setName("Nathan");
user.setNumberOfGoats(16); // throws error: NumberOfGoats does not exist in User.