As was recently announced, Railo, the open source CF engine, has finally given ColdFusion to the masses.  March 31st saw the release of the first 3.1 public beta, providing full feature compliance with Adobe’s ColdFusion 8 standard, and allowing developers to begin porting over existing sites to Railo.  The ability to port over existing sites, or to spin up entire servers for a client without running into the pesky licensing costs of ColdFusion is one of the developments that has me the most excited about Railo.

Previous versions of Railo (including the promising but ultimately not CF8-compliant and buggy 3.0) have been known to provide phenomenal speed increases, but without the ability to fully support the CF standard there have been compatibility issues with web software firms attempting to make a move to Railo.  This, combined with a lack of true enterprise capabilities led many to dub the platform unready for prime time.  Railo 3.1 is about to change all of that, at least once it is finally out of beta.

I have not yet had time to play with Railo 3.1 too much, but they provide an express install that isn’t really an install, so it has been very easy.  Just extract to a folder, double click the ’start’ script to start the application/web server, and then you can immediately browse to it at http://localhost:8888.  Drop code into the Railo webroot folder, and you can start testing existing apps against Railo.  The administrator for Railo 3.0 was very sparse compared to the CF administrator that ColdFusion developers know and love.  Not so with Railo 3.1.  The server adminstrator which manages the more global settings has a separate password from the web administrator, and there are numerous settings available, many specifically tailored towards compatibility with CF8, but there are also enhancements beyond what Adobe provides. Additional enhanced selections within the administrator, such as “convert 0000-00-00 MySQL dates to NULL” seem like a sensible upgrade to the default behavior of CF, others probably depend on the needs of your application.  Missing at this point in the release is the much ballyhooed cfvideo tag, a cluster scope (though Railo supports J2EE sessions at this point), and clustered caching.  With a CF license costs no longer at issue, expect Railo’s clustering functionality to get a full workout in the coming months.

Installing extensions, and restarting the cf service are available within the administrator as well.  Things like Galleon forums, the Mach-II framework, and other open source CF goodies.  Additional providers can be added via the server, too, (this works very similarly to how plugin providers are added via the Eclipse IDE) and updating the server software is also possible within the Railo admin itself.  One of the weirdest things for anyone that has restarted a ColdFusion service before is that Railo’s cf restart is darned-near instantaneous.  Everyone gets logged out on the server, as sessions and other scopes are cleared, but other than that, there is no painful delay waiting for the service to kick in while site visitors are crashing into technical looking 500 server error screens as is so often the case with a typical ColdFusion restart.  It’s…eerie.  It is also a distinct improvement, but performance has always been Railo’s most promising and consistent offering in their platform.

You can bet that many people across the internets have been tinkering with Railo 3.1 lately, especially in tandem with Amazon’s EC2 or similar cloud service, in order to provide things like open source load-balanced J2EE session-scoped cluster farms.  Suddenly, stunningly, ColdFusion developers are now enjoying something that PHP developers have been able to enjoy for years.  I welcome an open CF8 standard (whether Adobe has created or simply joined the CF standard is unclear) and a fully-featured open source ColdFusion application server.  It is clear that this can only mean good things for CFML and ColdFusion developers in the future.

What is not so clear, however, is how Railo’s other open source competitor Blue Dragon has fared, but with many members of the Blue Dragon team leaving (and some of them joining the Railo team), chances are that it will not fare very well.  Equally unclear is Adobe’s opinion on Railo, and how its official release might come to affect its bottom line.  Whatever the case, the cat is out of the bag now.  We’ve seen the future, and the future is open source.

Viva la Revolucion!

A little under a year ago I was ‘oohing and ahhing’ over the official launch of Adobe AIR, and the amazing potential it opened up for blurring the lines between web and desktop applications. Lately – well, since Flashbelt 2008, I’ve been ‘oohing and ahhing’ over Processing …

(I’m honored that this piece was used in a Create Digital Motion article announcing Processing’s move from Beta to the official Processing 1.0!)

Adobe AIR and Processing?! Apples and oranges, I know. But I tend to obsess over things – whether it’s indenting my CSS properties, dropping my curly brackets to the next line, or exploring new software and languages to experiment with – like ActionScript 3, Processing, or NodeBox.

I think Processing has become more than just a fling…

Nick Longtin, colleague and teacher of many of my programming skills, once commented that Processing was right up my alley – and he was right. The creative potential has me quite addicted, and I think Processing has become more than just a fling. An area where my eye for design and my obsessive coding habits play nicely together. An area where stunning and inspiring work is easy to find. Where late nights of coding are rewarded with visual output, not some big query result to loop through…

Yeah, I Heart Processing.

Many of my experiments have been posted to my Flickr photostream – check ‘em out and let me know what you think!

More experiments with Processing and Particles. This one uses the wonderful Traer Physics library.

Rather than writing a custom Particle class and applying forces to them individually (as in my previous particle post), all I need to do is create a ParticleSystem instance, add forces as desired (none in this case), and Traer does the rest.

In this example, I continuously add particles in the center with random velocities, and continuously remove them when they’ve grown old. The particle.age() property also controls the size and transparency of each particle, which is simply an ellipse with a teal-ish fill. The moon is a PNG placed in the center. For a final touch, I use the built-in camera() function to zoom in an out, controlled by a Sine wave.

Actually, this one uses 10,000 particles, and the equation:

float force = planet.mass * particle.mass / distanceSquared;

(Thanks Keith Peters!)

Particles are regenerated if they begin shooting off into space. Near the end of the animation, I decrease the center planet’s mass until it becomes negative, changing gravity into repulsion…

100% code animation built with Processing – uses a random color sampled from a photo of rust, 1000 particles and Perlin noise to control movement.
This experiment was based on my ActionScript 3.0 PerlinCurtain post.

I tend to be a very thorough and detail-oriented person… at least I hope so (there are other words for it, but we’ll leave it at that). So naturally, when I’m writing code – whether it’s xhtml, CSS, ActionScript etc – I try and keep things neat, clean and easy to read. I indent like it’s going out of style, I strive for consistent naming conventions, and I use descriptive variable and function names.

(more…)

UPDATE: I’ve discovered a serious flaw in this class… I plan to refactor things soon – stay tuned.

In an effort to simplify audio visualization experiments with ActionScript 3.0, I’ve developed a SoundData class. The class’s main attraction is centered around the flash.media.SoundMixer.computeSpectrum() method, but it also provides additional control over playback, including startSound(), stopSound() and toggle() methods. The class also allows manipulation over volume and panning.

(more…)

‘Twas the night before Christmas, when all through the house, just my keyboard was stirring, along side the mouse … (more…)

We’re getting soooo close to our Wonderfile beta launch….

An old salty dog programmer (also very successful money-wise) once told me. “A software application isn’t really done until it’s been rewritten from scratch at least five times.”

We’re on our fourth rewrite of Wonderfile. It doesn’t encapsulate our complete vision for the app, but we feel that it’s quite useful as it is, and definitely good enough to publically beta test.

What is Wonderfile? It is a completely new way to think about organizing electronic files. We’re done with the nested folders of the 80’s and have created a hierarchical tag-based framework for managing files. This is really different stuff – a paradigm shift. Comments from experienced IT pros we’ve shown early demos to…

* “Why hasn’t anyone else done this?”

* “I can use this in a ton of different ways.”

* “How can I invest?”

We’ll be posting the access code for our limited beta on this blog October 15th. We’ll let 250 testers in to the system – first come first serve. They’ll be given privileged account status (i.e. less expensive after the test is over) and will be able to influence future development of the system.

For a sneak preview, come see us demo Wonderfile to our peers at Minnedemo Oct. 11 (free beer for the first 200 attendees). Minnedemo is held at O’Gara’s in St. Paul – the demo’s start at 7:30 and we’re the fourth company on stage…

Visit – http://minnedemo.org to register.

I have a theory.

A web application will be at least 100% better if the developers who create it also actively use it.

It is akin to a meal prepared by an expert chef. The best chefs constantly sample their creations as they prepare a meal. When it is ready, they’ll serve it to their patrons and then sit down themselves to enjoy what they have lovingly created.

Like a chef, expert developers need to actively sample (test and use) their software while working on it, then sit down and consume their own code as a user would.

QA provided by testing experts definitely has its place – but I fear that sometimes developers (even good ones) miss significant opportunities to write better applications because they rely too heavily on testers / users to catch bugs and provide interface feedback. This reliance costs time – but even more significantly, we lose opportunities to improve the user experience because those who know how to change the code don’t take the time to actively engage and use the application. This lost opportunity for creative improvement could be avoided if developers spent an hour actively using the application for every 10 hours spent coding.

When I say using – I don’t mean quick tests, scripted testing, a little demo or anything like that – I mean actively using the application like their users will have to. I’m talking really, really use it and engage. A good chef will sit down and eat the meals he prepares – from that he draws inspiration for improvement. Programmers who consume the applications they write will create better software – hands down.