1. SSH in as the ubuntu user. It should use your existing Amazon key pair. If it doesn’t, go read up on how EC2 works.

2. Create a new user account and add the user to the admin group:

   sudo adduser fred
   sudo adduser fred admin

3. Copy your SSH key over to the new user:

   sudo mkdir -p /home/fred/.ssh
   sudo cp ~/.ssh/authorized_keys /home/fred/.ssh/
   sudo chown -R fred:fred /home/fred/.ssh
   sudo chmod -R 0700 /home/fred/.ssh

4. Add your new user to /etc/sudoers.

   export EDITOR=nano && sudo -E visudo
   fred ALL=(ALL) ALL

5. Logout. SSH back in as your new user.

6. Remove the Railo admin password and restart Railo:

   sudo perl -p -i.bak -e 's/password=".+?"/password=""/g' /opt/railo/lib/railo-server/context/railo-server.xml
   /etc/init.d/railo_ctl restart

7. Reset your Railo Server password at http://./railo-context/admin/server.cfm. Set up a default password and reset all of the web context passwords.

8. Change the Mango admin password by logging into http://./admin with admin/railo4all. Create a new user account with your own name while you are in there.

9. Reset your mySQL password (current is railo4all) and make a new user:

   mysql -u root -p mysql
   update user set password=password('newpassword') where user = 'root';
   create user 'railo'@'127.0.0.1' identified by 'newpassword';
   grant select, insert, update, delete, alter, index, drop, create on mango.* to 'railo'@'127.0.0.1';
   flush privileges;
   \q

   If you aren’t using ORM, your grant statement can be reduced to the first 4 CRUD operations.

10. Go into your Railo Web Admin at http://./railo-context/admin/web.cfm and change the Mango datasource to use user railo and the new password. Lock down permissions appropriately.

11. Set up Git, and make a repo to cover your web root:

    sudo apt-get install -y git-core
    mkdir -p ~/git/www.git
    cd ~/git/www.git
    git init --bare
    git config core.bare false
    git config core.worktree /var/www
    git config receive.denycurrentbranch ignore
    sudo chown -R fred:fred /var/www
    cat > /var/www/.gitignore
        WEB-INF
        ~*
        *~
        settings.xml
    git add /var/www
    git commit -m 'Created repo'
    cat > hooks/post-update
        #!/bin/sh
        GIT_WORK_TREE=/var/www GIT_DIR=/home/fred/git/www.git git checkout -q -f
    chmod +x hooks/post-update
    

    You should now be able to clone this repo with something like fred@host:git/www.git. Committing and pushing to Git checks out the files to your web root, so you never need to transfer anything manually unless it’s too big to put in Git.

12. Fix SES URLs in Apache+Tomcat. You’ll need to edit /etc/apache2/apache2.conf to include a /*.cfm/* rule.

Wait. I’m not talking about ColdFusion the server-side framework. I’m talking about ColdFusion the language and development platform. I’m talking about the data-oriented language with primitives for building task-centric applications.

I’m talking about the ColdFusion language that already has a cross-compiler to Java source and JVM bytecode.

If you look at Android development, it’s not all that different compared to CF development with an MVC framework like Framework/1. Each Android task equates to a FW1 View, and has similar enter and leave Controller validation. Android apps are backed by SQLite storage, and generally use the same Model-style access to their database. Apps can start Service components that can function as asynchronous threads, or as persistent Application-level objects.

I’m not advocating porting the CF runtime to Android, nor client-server style development where the app UI is just a wrapper around WebKit¹. I’m saying you take the CFML tags and CFScript language and cross-compile them to Java source and/or JVM bytecode. You write apps like this:

<cfwindow id="hello">
    <cfform action="#nextthing">
        <cfinput type="text" required="true" id="loginEmail" message="#localize.emailRequired#" label="#localize.emailLabel#">
        <cfinput type="submit" id="loginSubmit" label="#localize.next#">
    </cfform>
</cfwindow>

And poof, presto-magic, Eclipse compiles this into a native APK using native widgets and puts it on your Android. There are already a ton of CF tags for UI that are fairly render-agnostic. I’m not saying it would be a perfect fit, nor that every tag would be useful, but it’s a heckuva start.

Adobe has already made it pretty clear that they think Flash is the future for Android development. Some smart person who wants to make a ton of money should build a few proofs-of-concept and go to the smart guys at Railo with a business plan. If they turn you down, go through the presentation and replace Java/Android with .NET/WP7 and go talk to NewAtlanta. Once your pile of money is big enough, you shovel it into building an Objective C cross-compiler and start targeting iPhone.

ColdFusion is so money mobile and it doesn’t even know it!

Footnotes:

1. You’ve already got Appcelerator Titanium, PhoneGap, and other competitors in that space.

I’ve been teaching ColdFusion as part of a BS degree for a bit more than a year now. It’s been going well. The ColdFusion course follows courses in HTML, CSS, ActionScript, Flex, JavaScript, jQuery, PHP, and SQL. I start with procedural CF, refactor that into a simple MVC pattern with UDFs, refactor that again into full OO with components, and refactor that a final time to use ORM and FW/1. The students get to see CF at multiple levels of complexity, and they get practice with taking older code and upgrading it to newer coding techniques.

But I have recently come to question the utility of starting with pure procedural CF. Is it still relevant?

The students get to my class with a heavy OO background from their ActionScript, Flex, and JavaScript courses. The PHP course serves as their introduction to server-side coding, and is purely procedural. So do I really need to revisit procedural server-side code (such as cfmodule)? Is the business need for entry-level CF coders to be able to code at all complexity levels, or would stronger OO and framework skills be better received?

You can’t have it both ways—there is a finite amount of class time.